@autobe/agent 0.14.6 → 0.15.1

package/src/orchestrate/analyze/orchestrateAnalyzeReviewer.ts

@@ -2,7 +2,6 @@ import { MicroAgentica } from "@agentica/core";
 import { ILlmSchema } from "@samchon/openapi";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
-import { randomBackoffStrategy } from "../../utils/backoffRetry";
 import { enforceToolCall } from "../../utils/enforceToolCall";
 import { transformAnalyzeReviewerHistories } from "./transformAnalyzeReviewerHistories";
 
@@ -20,8 +19,7 @@ export const orchestrateAnalyzeReviewer = async <
     vendor: ctx.vendor,
     controllers: [],
     config: {
-      locale: ctx.config?.locale,
-      backoffStrategy: randomBackoffStrategy,
+      ...ctx.config,
       executor: {
         describe: null,
       },

package/src/orchestrate/analyze/orchestrateAnalyzeWrite.ts

@@ -6,7 +6,6 @@ import typia from "typia";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
-import { randomBackoffStrategy } from "../../utils/backoffRetry";
 import { enforceToolCall } from "../../utils/enforceToolCall";
 import {
   AutoBeAnalyzeFileSystem,
@@ -46,8 +45,7 @@ export const orchestrateAnalyzeWrite = <Model extends ILlmSchema.Model>(
     model: ctx.model,
     vendor: ctx.vendor,
     config: {
-      locale: ctx.config?.locale,
-      backoffStrategy: randomBackoffStrategy,
+      ...ctx.config,
       executor: {
         describe: null,
       },

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

@@ -0,0 +1,75 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import {
+  AutoBeAnalyzeHistory,
+  AutoBePrismaHistory,
+  IAutoBePrismaCompileResult,
+} from "@autobe/interface";
+import { v4 } from "uuid";
+
+import { AutoBeState } from "../../../context/AutoBeState";
+
+export const transformInterfaceAssetHistories = (
+  state: AutoBeState,
+): Array<
+  IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
+> => {
+  const analyze: AutoBeAnalyzeHistory = state.analyze!;
+  const prisma: AutoBePrismaHistory = state.prisma!;
+  return [
+    {
+      id: v4(),
+      created_at: new Date().toISOString(),
+      type: "assistantMessage",
+      text: [
+        "Requirement analysis and Prisma DB schema generation are ready.",
+        "",
+        "Call the provided tool function to generate the OpenAPI document",
+        "referencing below requirement analysis and Prisma DB schema.",
+        "",
+        // User Request
+        `## User Request`,
+        "",
+        analyze.reason,
+        "",
+        // Requirement Analysis Report
+        `## Requirement Analysis Report`,
+        "",
+        "```json",
+        JSON.stringify(analyze.files),
+        "```",
+      ].join("\n"),
+    },
+    {
+      id: v4(),
+      created_at: new Date().toISOString(),
+      type: "assistantMessage",
+      text: [
+        "Database schema and entity relationship diagrams are ready.",
+        "You should also look at this and consider logic including membership/login and token issuance.",
+        "You can use table's name to define role in operations.",
+        "",
+        "## Critical Schema Verification Instructions",
+        "",
+        "**IMPORTANT**: When generating API operations and descriptions:",
+        "1. ONLY reference fields that ACTUALLY EXIST in the Prisma schema below",
+        "2. NEVER assume common fields like `deleted_at`, `created_by`, `updated_by`, `is_deleted` exist",
+        "3. For DELETE operations:",
+        "   - If schema HAS soft delete fields (e.g., `deleted_at`), describe soft delete behavior",
+        "   - If schema LACKS soft delete fields, describe hard delete behavior",
+        "4. Verify EVERY field reference against the actual schema before including in descriptions",
+        "",
+        "## Prisma DB Schema",
+        "```json",
+        JSON.stringify(prisma.schemas),
+        "```",
+        "",
+        "## Entity Relationship Diagrams",
+        "```json",
+        JSON.stringify(
+          (prisma.compiled as IAutoBePrismaCompileResult.ISuccess).diagrams,
+        ),
+        "```",
+      ].join("\n"),
+    },
+  ];
+};

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

@@ -0,0 +1,69 @@
+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 transformInterfaceComplementHistories = (
+  state: AutoBeState,
+  document: AutoBeOpenApi.IDocument,
+  missed: string[],
+): 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: [
+      "Here is the OpenAPI operations what you AI have made:",
+      "",
+      "```json",
+      JSON.stringify(document.operations),
+      "```",
+    ].join("\n"),
+  },
+  {
+    type: "systemMessage",
+    id: v4(),
+    created_at: new Date().toISOString(),
+    text: AutoBeSystemPromptConstant.INTERFACE_SCHEMA,
+  },
+  {
+    type: "assistantMessage",
+    id: v4(),
+    created_at: new Date().toISOString(),
+    text: [
+      "Here is the OpenAPI schemas what you AI have made:",
+      "",
+      "```json",
+      JSON.stringify(document.components.schemas),
+      "```",
+    ].join("\n"),
+  },
+  {
+    type: "systemMessage",
+    id: v4(),
+    created_at: new Date().toISOString(),
+    text: AutoBeSystemPromptConstant.INTERFACE_COMPLEMENT,
+  },
+  {
+    type: "assistantMessage",
+    id: v4(),
+    created_at: new Date().toISOString(),
+    text: [
+      "You AI have missed below schema types:",
+      "",
+      ...missed.map((s) => `- ${s}`),
+    ].join("\n"),
+  },
+];

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

@@ -0,0 +1,34 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import { AutoBeInterfaceGroup } from "@autobe/interface/src/histories/contents/AutoBeInterfaceGroup";
+import { v4 } from "uuid";
+
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+import { AutoBeState } from "../../../context/AutoBeState";
+import { transformInterfaceAssetHistories } from "./transformInterfaceAssetHistories";
+
+export const transformInterfaceEndpointHistories = (
+  state: AutoBeState,
+  group: AutoBeInterfaceGroup,
+): Array<
+  IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
+> => [
+  {
+    type: "systemMessage",
+    id: v4(),
+    created_at: new Date().toISOString(),
+    text: AutoBeSystemPromptConstant.INTERFACE_ENDPOINT,
+  },
+  ...transformInterfaceAssetHistories(state),
+  {
+    type: "assistantMessage",
+    id: v4(),
+    created_at: new Date().toISOString(),
+    text: [
+      "Here is the target group for the endpoints:",
+      "",
+      "```json",
+      JSON.stringify(group),
+      "```",
+    ].join("\n"),
+  },
+];

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

@@ -0,0 +1,32 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import { v4 } from "uuid";
+
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+import { AutoBeState } from "../../../context/AutoBeState";
+import { transformInterfaceAssetHistories } from "./transformInterfaceAssetHistories";
+import { transformInterfacePrerequisiteHistories } from "./transformInterfacePrerequisiteHistories";
+
+export const transformInterfaceGroupHistories = (
+  state: AutoBeState,
+): Array<
+  IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
+> => {
+  const prerequisite = transformInterfacePrerequisiteHistories(state);
+  if (prerequisite !== null) return prerequisite;
+
+  return [
+    {
+      id: v4(),
+      created_at: new Date().toISOString(),
+      type: "systemMessage",
+      text: AutoBeSystemPromptConstant.INTERFACE_ENDPOINT,
+    },
+    ...transformInterfaceAssetHistories(state),
+    {
+      id: v4(),
+      created_at: new Date().toISOString(),
+      type: "systemMessage",
+      text: AutoBeSystemPromptConstant.INTERFACE_GROUP,
+    },
+  ];
+};

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

@@ -0,0 +1,34 @@
+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 transformInterfaceOperationHistories = (
+  state: AutoBeState,
+  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"),
+  },
+];

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

@@ -0,0 +1,66 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import { v4 } from "uuid";
+
+import { AutoBeState } from "../../../context/AutoBeState";
+
+export const transformInterfacePrerequisiteHistories = (
+  state: AutoBeState,
+): Array<
+  IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
+> | null => {
+  if (state.analyze === null)
+    return [
+      {
+        id: v4(),
+        created_at: new Date().toISOString(),
+        type: "systemMessage",
+        text: [
+          "Requirement analysis is not yet completed.",
+          "Don't call the any tool function,",
+          "but say to process the requirement analysis.",
+        ].join(" "),
+      },
+    ];
+  else if (state.prisma === null)
+    return [
+      {
+        id: v4(),
+        created_at: new Date().toISOString(),
+        type: "systemMessage",
+        text: [
+          "Prisma DB schema generation is not yet completed.",
+          "Don't call the any tool function,",
+          "but say to process the Prisma DB schema generation.",
+        ].join(" "),
+      },
+    ];
+  else if (state.analyze.step !== state.prisma.step)
+    return [
+      {
+        id: v4(),
+        created_at: new Date().toISOString(),
+        type: "systemMessage",
+        text: [
+          "Prisma DB schema generation has not been updated",
+          "for the latest requirement analysis.",
+          "Don't call the any tool function,",
+          "but say to re-process the Prisma DB schema generation.",
+        ].join(" "),
+      },
+    ];
+  else if (state.prisma.compiled.type !== "success")
+    return [
+      {
+        id: v4(),
+        created_at: new Date().toISOString(),
+        type: "systemMessage",
+        text: [
+          "Prisma DB schema generation has not been updated",
+          "for the latest requirement analysis.",
+          "Don't call the any tool function,",
+          "but say to re-process the Prisma DB schema generation.",
+        ].join(" "),
+      },
+    ];
+  return null;
+};

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

@@ -0,0 +1,34 @@
+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 transformInterfaceSchemaHistories = (
+  state: AutoBeState,
+  operations: AutoBeOpenApi.IOperation[],
+): Array<
+  IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
+> => [
+  {
+    type: "systemMessage",
+    id: v4(),
+    created_at: new Date().toISOString(),
+    text: AutoBeSystemPromptConstant.INTERFACE_SCHEMA,
+  },
+  ...transformInterfaceAssetHistories(state),
+  {
+    type: "assistantMessage",
+    id: v4(),
+    created_at: new Date().toISOString(),
+    text: [
+      "Here is the list of API operations you have to implement its types:",
+      "",
+      "```json",
+      JSON.stringify(operations),
+      "```",
+    ].join("\n"),
+  },
+];

package/src/orchestrate/interface/orchestrateInterface.ts

@@ -1,7 +1,7 @@
 import {
   AutoBeAssistantMessageHistory,
   AutoBeInterfaceCompleteEvent,
-  AutoBeInterfaceEndpointsEvent,
+  AutoBeInterfaceGroupsEvent,
   AutoBeInterfaceHistory,
   AutoBeOpenApi,
 } from "@autobe/interface";
@@ -11,9 +11,10 @@ import { v4 } from "uuid";
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { IAutoBeApplicationProps } from "../../context/IAutoBeApplicationProps";
 import { orchestrateInterfaceComplement } from "./orchestrateInterfaceComplement";
-import { orchestrateInterfaceComponents } from "./orchestrateInterfaceComponents";
 import { orchestrateInterfaceEndpoints } from "./orchestrateInterfaceEndpoints";
+import { orchestrateInterfaceGroups } from "./orchestrateInterfaceGroups";
 import { orchestrateInterfaceOperations } from "./orchestrateInterfaceOperations";
+import { orchestrateInterfaceSchemas } from "./orchestrateInterfaceSchemas";
 
 export const orchestrateInterface =
   <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>) =>
@@ -29,24 +30,32 @@ export const orchestrateInterface =
       step: ctx.state().analyze?.step ?? 0,
     });
 
-    const init: AutoBeAssistantMessageHistory | AutoBeInterfaceEndpointsEvent =
-      await orchestrateInterfaceEndpoints(ctx);
+    const init: AutoBeAssistantMessageHistory | AutoBeInterfaceGroupsEvent =
+      await orchestrateInterfaceGroups(ctx);
     if (init.type === "assistantMessage") {
       ctx.dispatch(init);
       ctx.histories().push(init);
       return init;
     } else ctx.dispatch(init);
 
-    // OPERATIONS
+    // ENDPOINTS & OPERATIONS
+    const endpoints: AutoBeOpenApi.IEndpoint[] =
+      await orchestrateInterfaceEndpoints(ctx, init.groups);
     const operations: AutoBeOpenApi.IOperation[] =
-      await orchestrateInterfaceOperations(ctx, init.endpoints);
+      await orchestrateInterfaceOperations(ctx, endpoints);
 
     // TYPE SCHEMAS
     const document: AutoBeOpenApi.IDocument = {
       operations,
-      components: await orchestrateInterfaceComponents(ctx, operations),
+      components: {
+        authorization: ctx.state().analyze?.roles ?? [],
+        schemas: await orchestrateInterfaceSchemas(ctx, operations),
+      },
     };
-    document.components = await orchestrateInterfaceComplement(ctx, document);
+    document.components.schemas = await orchestrateInterfaceComplement(
+      ctx,
+      document,
+    );
 
     // DO COMPILE
     const result: AutoBeInterfaceHistory = {

package/src/orchestrate/interface/orchestrateInterfaceComplement.ts

@@ -8,20 +8,19 @@ import {
 import { OpenApiV3_1Emender } from "@samchon/openapi/lib/converters/OpenApiV3_1Emender";
 import { IPointer } from "tstl";
 import typia from "typia";
-import { v4 } from "uuid";
 
-import { AutoBeSystemPromptConstant } from "../../constants/AutoBeSystemPromptConstant";
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
 import { enforceToolCall } from "../../utils/enforceToolCall";
 import { forceRetry } from "../../utils/forceRetry";
-import { transformInterfaceHistories } from "./transformInterfaceHistories";
+import { transformInterfaceComplementHistories } from "./histories/transformInterfaceComplementHistories";
+import { IAutoBeInterfaceComplementApplication } from "./structures/IAutoBeInterfaceComplementApplication";
 
 export function orchestrateInterfaceComplement<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   document: AutoBeOpenApi.IDocument,
   life: number = 8,
-): Promise<AutoBeOpenApi.IComponents> {
+): Promise<Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>> {
   return forceRetry(() => step(ctx, document, life));
 }
 
@@ -29,9 +28,11 @@ async function step<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   document: AutoBeOpenApi.IDocument,
   retry: number,
-): Promise<AutoBeOpenApi.IComponents> {
+): Promise<Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>> {
   const missed: string[] = getMissed(document);
-  if (missed.length === 0 || retry <= 0) return document.components;
+  if (missed.length === 0 || retry <= 0) {
+    return document.components.schemas;
+  }
 
   const pointer: IPointer<Record<
     string,
@@ -48,34 +49,11 @@ async function step<Model extends ILlmSchema.Model>(
         describe: null,
       },
     },
-    histories: [
-      ...transformInterfaceHistories(
-        ctx.state(),
-        AutoBeSystemPromptConstant.INTERFACE_COMPLEMENT,
-      ),
-      {
-        id: v4(),
-        created_at: new Date().toISOString(),
-        type: "assistantMessage",
-        text: [
-          "Here is the OpenAPI document what you've made:",
-          "",
-          "```json",
-          JSON.stringify(document),
-          "```",
-        ].join("\n"),
-      },
-      {
-        id: v4(),
-        created_at: new Date().toISOString(),
-        type: "assistantMessage",
-        text: [
-          "You have missed below schema types in the document.components.schemas:",
-          "",
-          ...missed.map((s) => `- ${s}`),
-        ].join("\n"),
-      },
-    ],
+    histories: transformInterfaceComplementHistories(
+      ctx.state(),
+      document,
+      missed,
+    ),
     controllers: [
       createApplication({
         model: ctx.model,
@@ -114,18 +92,18 @@ async function step<Model extends ILlmSchema.Model>(
     created_at: new Date().toISOString(),
   });
 
-  const newComponents: AutoBeOpenApi.IComponents = {
-    schemas: {
-      ...pointer.value,
-      ...document.components.schemas,
-    },
-    authorization: document.components.authorization,
+  const newSchemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> = {
+    ...pointer.value,
+    ...document.components.schemas,
   };
   return step(
     ctx,
     {
       ...document,
-      components: newComponents,
+      components: {
+        ...document.components,
+        schemas: newSchemas,
+      },
     },
     retry - 1,
   );
@@ -170,18 +148,18 @@ function createApplication<Model extends ILlmSchema.Model>(props: {
       complementComponents: (next) => {
         props.build(next.schemas);
       },
-    } satisfies IApplication,
+    } satisfies IAutoBeInterfaceComplementApplication,
   };
 }
 
 const claude = typia.llm.application<
-  IApplication,
+  IAutoBeInterfaceComplementApplication,
   "claude",
   { reference: true }
 >();
 const collection = {
   chatgpt: typia.llm.application<
-    IApplication,
+    IAutoBeInterfaceComplementApplication,
     "chatgpt",
     { reference: true }
   >(),
@@ -190,56 +168,3 @@ const collection = {
   deepseek: claude,
   "3.1": claude,
 };
-
-interface IApplication {
-  /**
-   * Complements missing schema types
-   *
-   * This method fills in schema definitions that are referenced via $ref but
-   * not yet defined in the `components.schemas` section. For example, if an API
-   * operation references `{ "$ref": "#/components/schemas/UserProfile" }` but
-   * `UserProfile` type is not defined in `components.schemas`, this method will
-   * add the missing schema definition.
-   *
-   * This function is designed to be called via AI function calling mechanism to
-   * ensure the OpenAPI document is complete and all referenced schemas are
-   * properly defined.
-   */
-  complementComponents(props: IComplementComponentsProps): void;
-}
-interface IComplementComponentsProps {
-  /**
-   * A collection of missing schema definitions that need to be added to the
-   * OpenAPI document's `components.schemas` section.
-   *
-   * This object contains schema definitions for types that are referenced but
-   * not yet defined:
-   *
-   * - Key: Schema name (`string`): The name of the schema type that will be
-   *   referenced in $ref statements
-   * - Value: `AutoBeOpenApi.IJsonSchema` - The complete JSON Schema definition
-   *   for that type
-   *
-   * Example structure:
-   *
-   * ```typescript
-   * {
-   *   "UserProfile": {
-   *     "type": "object",
-   *     "properties": {
-   *       "id": { "type": "string" },
-   *       "name": { "type": "string" },
-   *       "email": { "type": "string", "format": "email" }
-   *     },
-   *     "required": ["id", "name", "email"]
-   *   }
-   * }
-   * ```
-   *
-   * Each schema definition follows the JSON Schema specification and will be
-   * directly inserted into the OpenAPI document's components.schemas section,
-   * making them available for $ref references throughout the API
-   * specification.
-   */
-  schemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>;
-}