@autobe/agent 0.3.22 → 0.3.24

package/src/orchestrate/interface/orchestrateInterfaceComplement.ts

@@ -0,0 +1,235 @@
+import { IAgenticaController, MicroAgentica } from "@agentica/core";
+import { AutoBeOpenApi } from "@autobe/interface";
+import {
+  ILlmApplication,
+  ILlmSchema,
+  OpenApiTypeChecker,
+} from "@samchon/openapi";
+import { OpenApiV3_1Emender } from "@samchon/openapi/lib/converters/OpenApiV3_1Emender";
+import { IPointer } from "tstl";
+import typia from "typia";
+
+import { AutoBeSystemPromptConstant } from "../../constants/AutoBeSystemPromptConstant";
+import { AutoBeContext } from "../../context/AutoBeContext";
+import { assertSchemaModel } from "../../context/assertSchemaModel";
+import { transformInterfaceHistories } from "./transformInterfaceHistories";
+
+export function orchestrateInterfaceComplement<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  document: AutoBeOpenApi.IDocument,
+  retry: number = 8,
+): Promise<AutoBeOpenApi.IComponents> {
+  return step(ctx, document, retry);
+}
+
+async function step<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  document: AutoBeOpenApi.IDocument,
+  retry: number,
+): Promise<AutoBeOpenApi.IComponents> {
+  const missed: string[] = getMissed(document);
+  if (missed.length === 0 || retry <= 0) return document.components;
+
+  const pointer: IPointer<Record<
+    string,
+    AutoBeOpenApi.IJsonSchemaDescriptive
+  > | null> = {
+    value: null,
+  };
+  const agentica: MicroAgentica<Model> = new MicroAgentica({
+    model: ctx.model,
+    vendor: ctx.vendor,
+    config: {
+      ...(ctx.config ?? {}),
+      executor: {
+        describe: null,
+      },
+    },
+    histories: [
+      ...transformInterfaceHistories(
+        ctx.state(),
+        AutoBeSystemPromptConstant.INTERFACE_COMPLEMENT,
+      ),
+      {
+        type: "assistantMessage",
+        text: [
+          "Here is the OpenAPI document what you've made:",
+          "",
+          "```json",
+          JSON.stringify(document),
+          "```",
+        ].join("\n"),
+      },
+      {
+        type: "assistantMessage",
+        text: [
+          "You have missed below schema types in the document.components.schemas:",
+          "",
+          ...missed.map((s) => `- ${s}`),
+        ].join("\n"),
+      },
+    ],
+    tokenUsage: ctx.usage(),
+    controllers: [
+      createApplication({
+        model: ctx.model,
+        build: (next) => {
+          pointer.value = (OpenApiV3_1Emender.convertComponents({
+            schemas: next,
+          }).schemas ?? {}) as Record<
+            string,
+            AutoBeOpenApi.IJsonSchemaDescriptive
+          >;
+        },
+      }),
+    ],
+  });
+  agentica.on("request", async (event) => {
+    event.body.tool_choice = "required";
+  });
+
+  await agentica.conversate("Fill missing schema types please");
+  if (pointer.value === null) {
+    // unreachable
+    throw new Error(
+      "Failed to fill missing schema types. No response from agentica.",
+    );
+  }
+  ctx.dispatch({
+    type: "interfaceComplement",
+    missed,
+    schemas: pointer.value,
+    step: ctx.state().analyze?.step ?? 0,
+    created_at: new Date().toISOString(),
+  });
+
+  const newComponents: AutoBeOpenApi.IComponents = {
+    schemas: {
+      ...pointer.value,
+      ...document.components.schemas,
+    },
+    authorization: document.components.authorization,
+  };
+  return step(
+    ctx,
+    {
+      ...document,
+      components: newComponents,
+    },
+    retry - 1,
+  );
+}
+
+const getMissed = (document: AutoBeOpenApi.IDocument): string[] => {
+  const missed: Set<string> = new Set();
+  const check = (name: string) => {
+    if (document.components.schemas[name] === undefined) missed.add(name);
+  };
+  for (const op of document.operations) {
+    if (op.requestBody !== null) check(op.requestBody.typeName);
+    if (op.responseBody !== null) check(op.responseBody.typeName);
+  }
+  for (const value of Object.values(document.components.schemas))
+    OpenApiTypeChecker.visit({
+      components: document.components,
+      schema: value,
+      closure: (next) => {
+        if (OpenApiTypeChecker.isReference(next))
+          check(next.$ref.split("/").pop()!);
+      },
+    });
+  return Array.from(missed);
+};
+
+function createApplication<Model extends ILlmSchema.Model>(props: {
+  model: Model;
+  build: (
+    schemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>,
+  ) => void;
+}): IAgenticaController.IClass<Model> {
+  assertSchemaModel(props.model);
+  const application: ILlmApplication<Model> = collection[
+    props.model
+  ] as unknown as ILlmApplication<Model>;
+  return {
+    protocol: "class",
+    name: "interface",
+    application,
+    execute: {
+      complementComponents: (next) => {
+        props.build(next.schemas);
+      },
+    } satisfies IApplication,
+  };
+}
+
+const claude = typia.llm.application<
+  IApplication,
+  "claude",
+  { reference: true }
+>();
+const collection = {
+  chatgpt: typia.llm.application<
+    IApplication,
+    "chatgpt",
+    { reference: true }
+  >(),
+  claude,
+  llama: claude,
+  deepseek: claude,
+  "3.1": claude,
+  "3.0": typia.llm.application<IApplication, "3.0">(),
+};
+
+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>;
+}

package/src/orchestrate/interface/orchestrateInterfaceComponents.ts

@@ -1,11 +1,6 @@
 import { IAgenticaController, MicroAgentica } from "@agentica/core";
 import { AutoBeOpenApi } from "@autobe/interface";
-import {
-  ILlmApplication,
-  ILlmSchema,
-  IValidation,
-  OpenApiTypeChecker,
-} from "@samchon/openapi";
+import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
 import { OpenApiV3_1Emender } from "@samchon/openapi/lib/converters/OpenApiV3_1Emender";
 import { IPointer } from "tstl";
 import typia from "typia";
@@ -184,40 +179,6 @@ function createApplication<Model extends ILlmSchema.Model>(props: {
   const application: ILlmApplication<Model> = collection[
     props.model
   ] as unknown as ILlmApplication<Model>;
-  const validate = (next: unknown): IValidation => {
-    const result: IValidation<IMakeComponentsProps> =
-      typia.validate<IMakeComponentsProps>(next);
-    if (result.success === false) return result;
-    props.pointer.value = result.data.components;
-
-    const errors: IValidation.IError[] = [];
-    for (const value of Object.values(result.data.components.schemas)) {
-      OpenApiTypeChecker.visit({
-        components: result.data.components,
-        schema: value,
-        closure: (v) => {
-          if (OpenApiTypeChecker.isReference(v)) {
-            const key: string = v.$ref.split("/").at(-1)!;
-            if (result.data.components.schemas?.[key] === undefined)
-              errors.push({
-                path: `components.schemas.${key}`,
-                expected: "AutoBeOpenApi.IJsonSchemaDescriptive",
-                value: "undefined",
-              });
-          }
-        },
-      });
-    }
-    if (errors.length !== 0)
-      return {
-        success: false,
-        data: result.data,
-        errors,
-      };
-    return result;
-  };
-
-  application.functions[0].validate = validate;
   return {
     protocol: "class",
     name: "interface",
@@ -225,9 +186,6 @@ function createApplication<Model extends ILlmSchema.Model>(props: {
     execute: {
       makeComponents: async (next) => {
         await props.build(next.components);
-        return {
-          success: true,
-        };
       },
     } satisfies IApplication,
   };
@@ -303,22 +261,26 @@ interface IMakeComponentsProps {
    *
    * Example structure:
    *
-   *     components: {
-   *       schemas: {
-   *         IUser: {
-   *           type: "object",
-   *           properties: {
-   *             id: { type: "string", format: "uuid" },
-   *             email: { type: "string", format: "email" },
-   *             profile: { "$ref": "#/components/schemas/IUserProfile" }
-   *           },
-   *           required: ["id", "email"],
-   *           description: "User entity representing system account holders..."
+   * ```typescript
+   * {
+   *   components: {
+   *     schemas: {
+   *       IUser: {
+   *         type: "object",
+   *         properties: {
+   *           id: { type: "string", format: "uuid" },
+   *           email: { type: "string", format: "email" },
+   *           profile: { "$ref": "#/components/schemas/IUserProfile" }
    *         },
-   *         "IUser.ICreate": { ... },
-   *         // Additional schemas
-   *       }
+   *         required: ["id", "email"],
+   *         description: "User entity representing system account holders..."
+   *       },
+   *       "IUser.ICreate": { ... },
+   *       // Additional schemas
    *     }
+   *   }
+   * }
+   * ```
    */
   components: AutoBeOpenApi.IComponents;
 }

package/src/orchestrate/interface/orchestrateInterfaceEndpoints.ts

@@ -47,7 +47,7 @@ export async function orchestrateInterfaceEndpoints<
     controllers: [
       createApplication({
         model: ctx.model,
-        build: async (endpoints) => {
+        build: (endpoints) => {
           pointer.value = endpoints;
         },
       }),
@@ -79,7 +79,7 @@ export async function orchestrateInterfaceEndpoints<
 
 function createApplication<Model extends ILlmSchema.Model>(props: {
   model: Model;
-  build: (endpoints: AutoBeOpenApi.IEndpoint[]) => Promise<void>;
+  build: (endpoints: AutoBeOpenApi.IEndpoint[]) => void;
 }): IAgenticaController.IClass<Model> {
   assertSchemaModel(props.model);
 
@@ -91,11 +91,8 @@ function createApplication<Model extends ILlmSchema.Model>(props: {
     name: "interface",
     application,
     execute: {
-      makeEndpoints: async (next) => {
-        await props.build(next.endpoints);
-        return {
-          success: true,
-        };
+      makeEndpoints: (next) => {
+        props.build(next.endpoints);
       },
     } satisfies IApplication,
   };

package/src/orchestrate/interface/orchestrateInterfaceOperations.ts

@@ -104,7 +104,7 @@ async function process<Model extends ILlmSchema.Model>(
     controllers: [
       createApplication({
         model: ctx.model,
-        build: async (endpoints) => {
+        build: (endpoints) => {
           pointer.value = endpoints;
         },
         pointer,
@@ -129,7 +129,7 @@ async function process<Model extends ILlmSchema.Model>(
 
 function createApplication<Model extends ILlmSchema.Model>(props: {
   model: Model;
-  build: (operations: AutoBeOpenApi.IOperation[]) => Promise<void>;
+  build: (operations: AutoBeOpenApi.IOperation[]) => void;
   pointer: IPointer<AutoBeOpenApi.IOperation[] | null>;
 }): IAgenticaController.IClass<Model> {
   assertSchemaModel(props.model);
@@ -166,11 +166,8 @@ function createApplication<Model extends ILlmSchema.Model>(props: {
     name: "interface",
     application,
     execute: {
-      makeOperations: async (next) => {
-        await props.build(next.operations);
-        return {
-          success: true,
-        };
+      makeOperations: (next) => {
+        props.build(next.operations);
       },
     } satisfies IApplication,
   };

package/src/orchestrate/interface/transformInterfaceHistories.ts

@@ -83,6 +83,8 @@ export const transformInterfaceHistories = (
     {
       type: "assistantMessage",
       text: [
+        "Database schema and entity relationship diagrams are ready.",
+        "",
         "## Prisma DB Schema",
         "```json",
         JSON.stringify(state.prisma.result.schemas),

package/src/orchestrate/prisma/orchestratePrismaCompiler.ts

@@ -14,7 +14,6 @@ export function orchestratePrismaCompiler<Model extends ILlmSchema.Model>(
   files: Record<string, string>,
   retry: number = 8,
 ): Promise<IAutoBePrismaCompilerResult> {
-  files["main.prisma"] = MAIN_PRISMA_FILE;
   return step(ctx, files, retry);
 }
 
@@ -23,6 +22,9 @@ async function step<Model extends ILlmSchema.Model>(
   files: Record<string, string>,
   life: number,
 ): Promise<IAutoBePrismaCompilerResult> {
+  // FIX MAIN PRISMA FILE
+  files["main.prisma"] = MAIN_PRISMA_FILE;
+
   // TRY COMPILATION
   const result: IAutoBePrismaCompilerResult = await ctx.compiler.prisma({
     files,