@autobe/agent 0.28.1 → 0.29.0

package/src/orchestrate/interface/orchestrateInterfaceGroup.ts

@@ -0,0 +1,153 @@
+import { IAgenticaController } from "@agentica/core";
+import {
+  AutoBeEventSource,
+  AutoBeInterfaceGroupEvent,
+  AutoBePrismaHistory,
+} from "@autobe/interface";
+import { StringUtil } from "@autobe/utils";
+import { ILlmApplication, ILlmSchema, IValidation } 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 { transformInterfaceGroupHistory } from "./histories/transformInterfaceGroupHistory";
+import { IAutoBeInterfaceGroupApplication } from "./structures/IAutoBeInterfaceGroupApplication";
+
+export async function orchestrateInterfaceGroup<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  props: {
+    instruction: string;
+  },
+): Promise<AutoBeInterfaceGroupEvent> {
+  const start: Date = new Date();
+  const pointer: IPointer<IAutoBeInterfaceGroupApplication.IProps | null> = {
+    value: null,
+  };
+  const prisma: AutoBePrismaHistory | null = ctx.state().prisma;
+  const { metric, tokenUsage } = await ctx.conversate({
+    source: SOURCE,
+    controller: createController({
+      model: ctx.model,
+      build: (next) => {
+        pointer.value = next;
+      },
+      prismaSchemas: new Set(
+        prisma !== null
+          ? prisma.result.data.files
+              .map((f) => f.models)
+              .flat()
+              .map((m) => m.name)
+          : [],
+      ),
+    }),
+    enforceFunctionCall: true,
+    ...transformInterfaceGroupHistory({
+      state: ctx.state(),
+      instruction: props.instruction,
+    }),
+  });
+  if (pointer.value === null)
+    throw new Error("Failed to generate endpoint groups."); // unreachable
+  return {
+    type: SOURCE,
+    id: v7(),
+    created_at: start.toISOString(),
+    groups: pointer.value.groups,
+    metric,
+    tokenUsage,
+    step: ctx.state().analyze?.step ?? 0,
+  } satisfies AutoBeInterfaceGroupEvent;
+}
+
+function createController<Model extends ILlmSchema.Model>(props: {
+  model: Model;
+  build: (next: IAutoBeInterfaceGroupApplication.IProps) => void;
+  prismaSchemas: Set<string>;
+}): IAgenticaController.IClass<Model> {
+  assertSchemaModel(props.model);
+
+  const validate: Validator = (input) => {
+    const result: IValidation<IAutoBeInterfaceGroupApplication.IProps> =
+      typia.validate<IAutoBeInterfaceGroupApplication.IProps>(input);
+    if (result.success === false) return result;
+    const errors: IValidation.IError[] = [];
+    result.data.groups.forEach((group, i) => {
+      group.prismaSchemas.forEach((key, j) => {
+        if (props.prismaSchemas.has(key) === false)
+          errors.push({
+            expected: Array.from(props.prismaSchemas)
+              .map((s) => JSON.stringify(s))
+              .join(" | "),
+            value: key,
+            path: `groups[${i}].prismaSchemas[${j}]`,
+            description: StringUtil.trim`
+              The Prisma schema "${key}" does not exist in the current project.
+
+              Make sure to provide only the valid Prisma schema names that are present in your project.
+
+              Here is the list of available Prisma schemas in the project:
+
+              ${Array.from(props.prismaSchemas)
+                .map((s) => `- ${s}`)
+                .join("\n")}
+            `,
+          });
+      });
+    });
+    return errors.length === 0
+      ? result
+      : {
+          success: false,
+          data: result.data,
+          errors,
+        };
+  };
+  const application: ILlmApplication<Model> = collection[
+    props.model === "chatgpt"
+      ? "chatgpt"
+      : props.model === "gemini"
+        ? "gemini"
+        : "claude"
+  ](
+    validate,
+  ) satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
+  return {
+    protocol: "class",
+    name: SOURCE,
+    application,
+    execute: {
+      makeGroups: (next) => {
+        props.build(next);
+      },
+    } satisfies IAutoBeInterfaceGroupApplication,
+  };
+}
+
+const collection = {
+  chatgpt: (validate: Validator) =>
+    typia.llm.application<IAutoBeInterfaceGroupApplication, "chatgpt">({
+      validate: {
+        makeGroups: validate,
+      },
+    }),
+  claude: (validate: Validator) =>
+    typia.llm.application<IAutoBeInterfaceGroupApplication, "claude">({
+      validate: {
+        makeGroups: validate,
+      },
+    }),
+  gemini: (validate: Validator) =>
+    typia.llm.application<IAutoBeInterfaceGroupApplication, "gemini">({
+      validate: {
+        makeGroups: validate,
+      },
+    }),
+};
+
+type Validator = (
+  input: unknown,
+) => IValidation<IAutoBeInterfaceGroupApplication.IProps>;
+
+const SOURCE = "interfaceGroup" satisfies AutoBeEventSource;

package/src/orchestrate/interface/{orchestrateInterfaceOperations.ts → orchestrateInterfaceOperation.ts}

@@ -1,5 +1,6 @@
 import { IAgenticaController } from "@agentica/core";
 import {
+  AutoBeEventSource,
   AutoBeInterfaceOperationEvent,
   AutoBeOpenApi,
   AutoBeProgressEventBase,
@@ -16,24 +17,24 @@ import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
 import { divideArray } from "../../utils/divideArray";
 import { executeCachedBatch } from "../../utils/executeCachedBatch";
-import { transformInterfaceOperationHistories } from "./histories/transformInterfaceOperationHistories";
-import { orchestrateInterfaceOperationsReview } from "./orchestrateInterfaceOperationsReview";
+import { AutoBePreliminaryController } from "../common/AutoBePreliminaryController";
+import { transformInterfaceOperationHistory } from "./histories/transformInterfaceOperationHistory";
+import { orchestrateInterfaceOperationReview } from "./orchestrateInterfaceOperationReview";
 import { IAutoBeInterfaceOperationApplication } from "./structures/IAutoBeInterfaceOperationApplication";
 import { OperationValidator } from "./utils/OperationValidator";
 
-export async function orchestrateInterfaceOperations<
+export async function orchestrateInterfaceOperation<
   Model extends ILlmSchema.Model,
 >(
   ctx: AutoBeContext<Model>,
   props: {
     instruction: string;
     endpoints: AutoBeOpenApi.IEndpoint[];
-    capacity?: number;
   },
 ): Promise<AutoBeOpenApi.IOperation[]> {
   const matrix: AutoBeOpenApi.IEndpoint[][] = divideArray({
     array: props.endpoints,
-    capacity: props.capacity ?? AutoBeConfigConstant.INTERFACE_CAPACITY,
+    capacity: AutoBeConfigConstant.INTERFACE_CAPACITY,
   });
   const progress: AutoBeProgressEventBase = {
     total: matrix.flat().length,
@@ -45,6 +46,7 @@ export async function orchestrateInterfaceOperations<
   };
   return (
     await executeCachedBatch(
+      ctx,
       matrix.map((it) => async (promptCacheKey) => {
         const row: AutoBeOpenApi.IOperation[] = await divideAndConquer(ctx, {
           endpoints: it,
@@ -97,7 +99,7 @@ async function divideAndConquer<Model extends ILlmSchema.Model>(
     }
   }
   const newbie: AutoBeOpenApi.IOperation[] =
-    await orchestrateInterfaceOperationsReview(
+    await orchestrateInterfaceOperationReview(
       ctx,
       unique.toJSON().map((it) => it.second),
       props.reviewProgress,
@@ -116,83 +118,96 @@ async function process<Model extends ILlmSchema.Model>(
   },
 ): Promise<AutoBeOpenApi.IOperation[]> {
   const prefix: string = NamingConvention.camel(ctx.state().analyze!.prefix);
-  const pointer: IPointer<AutoBeOpenApi.IOperation[] | null> = {
-    value: null,
-  };
-  const { metric, tokenUsage } = await ctx.conversate({
-    source: "interfaceOperation",
-    histories: transformInterfaceOperationHistories({
-      state: ctx.state(),
-      endpoints: props.endpoints.toJSON(),
-      instruction: props.instruction,
-    }),
-    controller: createController({
-      model: ctx.model,
-      actors: ctx.state().analyze?.actors.map((it) => it.name) ?? [],
-      build: (operations) => {
-        pointer.value ??= [];
-        const matrix: AutoBeOpenApi.IOperation[][] = operations.map((op) => {
-          if (op.authorizationActors.length === 0)
-            return [
-              {
-                ...op,
-                path:
-                  "/" +
-                  [prefix, ...op.path.split("/")]
-                    .filter((it) => it !== "")
-                    .join("/"),
-                authorizationActor: null,
-                authorizationType: null,
-                prerequisites: [],
-              },
-            ];
-          return op.authorizationActors.map((actor) => ({
-            ...op,
-            path:
-              "/" +
-              [prefix, actor, ...op.path.split("/")]
-                .filter((it) => it !== "")
-                .join("/"),
-            authorizationActor: actor,
-            authorizationType: null,
-            prerequisites: [],
-          }));
-        });
-        pointer.value.push(...matrix.flat());
-        props.progress.completed += matrix.flat().length;
-        props.progress.total += operations
-          .map((op) =>
-            props.endpoints.has({ path: op.path, method: op.method })
-              ? op.authorizationActors.length === 0
-                ? 0
-                : op.authorizationActors.length - 1
-              : op.authorizationActors.length,
-          )
-          .reduce((a, b) => a + b, 0);
-      },
-    }),
-    enforceFunctionCall: true,
-    promptCacheKey: props.promptCacheKey,
-    message: "Make API operations",
+  const preliminary: AutoBePreliminaryController<
+    "analysisFiles" | "prismaSchemas"
+  > = new AutoBePreliminaryController({
+    application: typia.json.application<IAutoBeInterfaceOperationApplication>(),
+    source: SOURCE,
+    kinds: ["analysisFiles", "prismaSchemas"],
+    state: ctx.state(),
+  });
+  return await preliminary.orchestrate(ctx, async (out) => {
+    const pointer: IPointer<AutoBeOpenApi.IOperation[] | null> = {
+      value: null,
+    };
+    const result: AutoBeContext.IResult<Model> = await ctx.conversate({
+      source: SOURCE,
+      controller: createController({
+        preliminary,
+        model: ctx.model,
+        actors: ctx.state().analyze?.actors.map((it) => it.name) ?? [],
+        build: (operations) => {
+          pointer.value ??= [];
+          const matrix: AutoBeOpenApi.IOperation[][] = operations.map((op) => {
+            if (op.authorizationActors.length === 0)
+              return [
+                {
+                  ...op,
+                  path:
+                    "/" +
+                    [prefix, ...op.path.split("/")]
+                      .filter((it) => it !== "")
+                      .join("/"),
+                  authorizationActor: null,
+                  authorizationType: null,
+                  prerequisites: [],
+                },
+              ];
+            return op.authorizationActors.map((actor) => ({
+              ...op,
+              path:
+                "/" +
+                [prefix, actor, ...op.path.split("/")]
+                  .filter((it) => it !== "")
+                  .join("/"),
+              authorizationActor: actor,
+              authorizationType: null,
+              prerequisites: [],
+            }));
+          });
+          pointer.value.push(...matrix.flat());
+          props.progress.completed += matrix.flat().length;
+          props.progress.total += operations
+            .map((op) =>
+              props.endpoints.has({ path: op.path, method: op.method })
+                ? op.authorizationActors.length === 0
+                  ? 0
+                  : op.authorizationActors.length - 1
+                : op.authorizationActors.length,
+            )
+            .reduce((a, b) => a + b, 0);
+        },
+      }),
+      enforceFunctionCall: true,
+      promptCacheKey: props.promptCacheKey,
+      ...transformInterfaceOperationHistory({
+        endpoints: props.endpoints.toJSON(),
+        instruction: props.instruction,
+        prefix,
+        preliminary,
+      }),
+    });
+    if (pointer.value !== null) {
+      ctx.dispatch({
+        type: SOURCE,
+        id: v7(),
+        operations: pointer.value,
+        metric: result.metric,
+        tokenUsage: result.tokenUsage,
+        ...props.progress,
+        step: ctx.state().analyze?.step ?? 0,
+        created_at: new Date().toISOString(),
+      } satisfies AutoBeInterfaceOperationEvent);
+      return out(result)(pointer.value);
+    }
+    return out(result)(null);
   });
-  if (pointer.value === null) throw new Error("Failed to create operations."); // never be happened
-
-  ctx.dispatch({
-    type: "interfaceOperation",
-    id: v7(),
-    operations: pointer.value,
-    metric,
-    tokenUsage,
-    ...props.progress,
-    step: ctx.state().analyze?.step ?? 0,
-    created_at: new Date().toISOString(),
-  } satisfies AutoBeInterfaceOperationEvent);
-  return pointer.value;
 }
 
 function createController<Model extends ILlmSchema.Model>(props: {
   model: Model;
   actors: string[];
+  preliminary: AutoBePreliminaryController<"analysisFiles" | "prismaSchemas">;
   build: (
     operations: IAutoBeInterfaceOperationApplication.IOperation[],
   ) => void;
@@ -205,12 +220,17 @@ function createController<Model extends ILlmSchema.Model>(props: {
     const result: IValidation<IAutoBeInterfaceOperationApplication.IProps> =
       typia.validate<IAutoBeInterfaceOperationApplication.IProps>(next);
     if (result.success === false) return result;
+    else if (result.data.request.type !== "complete")
+      return props.preliminary.validate({
+        thinking: result.data.thinking,
+        request: result.data.request,
+      });
 
     const operations: IAutoBeInterfaceOperationApplication.IOperation[] =
-      result.data.operations;
+      result.data.request.operations;
     const errors: IValidation.IError[] = [];
     OperationValidator.validate({
-      path: "$input.operations",
+      path: "$input.request.operations",
       errors,
       operations,
     });
@@ -222,7 +242,7 @@ function createController<Model extends ILlmSchema.Model>(props: {
         op.authorizationActors.forEach((actor, j) => {
           if (props.actors.includes(actor) === true) return;
           errors.push({
-            path: `$input.operations[${i}].authorizationActors[${j}]`,
+            path: `$input.request.operations[${i}].authorizationActors[${j}]`,
             expected: `null | ${props.actors.map((str) => JSON.stringify(str)).join(" | ")}`,
             description: StringUtil.trim`
               Actor "${actor}" is not defined in the roles list.
@@ -255,11 +275,12 @@ function createController<Model extends ILlmSchema.Model>(props: {
 
   return {
     protocol: "class",
-    name: "interface",
+    name: SOURCE,
     application,
     execute: {
-      makeOperations: (next) => {
-        props.build(next.operations);
+      process: (next) => {
+        if (next.request.type === "complete")
+          props.build(next.request.operations);
       },
     } satisfies IAutoBeInterfaceOperationApplication,
   };
@@ -269,19 +290,19 @@ const collection = {
   chatgpt: (validate: Validator) =>
     typia.llm.application<IAutoBeInterfaceOperationApplication, "chatgpt">({
       validate: {
-        makeOperations: validate,
+        process: validate,
       },
     }),
   claude: (validate: Validator) =>
     typia.llm.application<IAutoBeInterfaceOperationApplication, "claude">({
       validate: {
-        makeOperations: validate,
+        process: validate,
       },
     }),
   gemini: (validate: Validator) =>
     typia.llm.application<IAutoBeInterfaceOperationApplication, "gemini">({
       validate: {
-        makeOperations: validate,
+        process: validate,
       },
     }),
 };
@@ -289,3 +310,5 @@ const collection = {
 type Validator = (
   input: unknown,
 ) => IValidation<IAutoBeInterfaceOperationApplication.IProps>;
+
+const SOURCE = "interfaceOperation" satisfies AutoBeEventSource;

package/src/orchestrate/interface/orchestrateInterfaceOperationReview.ts

@@ -0,0 +1,186 @@
+import { IAgenticaController } from "@agentica/core";
+import {
+  AutoBeEventSource,
+  AutoBeInterfaceOperationReviewEvent,
+  AutoBeOpenApi,
+  AutoBePrisma,
+  AutoBeProgressEventBase,
+} from "@autobe/interface";
+import { ILlmApplication, ILlmSchema, IValidation } from "@samchon/openapi";
+import { IPointer } from "tstl";
+import typia from "typia";
+import { v7 } from "uuid";
+
+import { AutoBeContext } from "../../context/AutoBeContext";
+import { AutoBePreliminaryController } from "../common/AutoBePreliminaryController";
+import { transformInterfaceOperationReviewHistory } from "./histories/transformInterfaceOperationReviewHistory";
+import { IAutoBeInterfaceOperationReviewApplication } from "./structures/IAutoBeInterfaceOperationReviewApplication";
+import { OperationValidator } from "./utils/OperationValidator";
+
+export async function orchestrateInterfaceOperationReview<
+  Model extends ILlmSchema.Model,
+>(
+  ctx: AutoBeContext<Model>,
+  operations: AutoBeOpenApi.IOperation[],
+  progress: AutoBeProgressEventBase,
+): Promise<AutoBeOpenApi.IOperation[]> {
+  try {
+    return await process(ctx, operations, progress);
+  } catch {
+    ++progress.completed;
+    return [];
+  }
+}
+
+async function process<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  operations: AutoBeOpenApi.IOperation[],
+  progress: AutoBeProgressEventBase,
+): Promise<AutoBeOpenApi.IOperation[]> {
+  const files: AutoBePrisma.IFile[] = ctx.state().prisma?.result.data.files!;
+  const preliminary: AutoBePreliminaryController<
+    "analysisFiles" | "prismaSchemas"
+  > = new AutoBePreliminaryController({
+    application:
+      typia.json.application<IAutoBeInterfaceOperationReviewApplication>(),
+    source: SOURCE,
+    kinds: ["analysisFiles", "prismaSchemas"],
+    state: ctx.state(),
+  });
+  return await preliminary.orchestrate(ctx, async (out) => {
+    const pointer: IPointer<IAutoBeInterfaceOperationReviewApplication.IComplete | null> =
+      {
+        value: null,
+      };
+    const result: AutoBeContext.IResult<Model> = await ctx.conversate({
+      source: SOURCE,
+      controller: createReviewController({
+        preliminary,
+        model: ctx.model,
+        prismaSchemas: files,
+        build: (next: IAutoBeInterfaceOperationReviewApplication.IComplete) => {
+          pointer.value = next;
+        },
+      }),
+      enforceFunctionCall: false,
+      ...transformInterfaceOperationReviewHistory({
+        preliminary,
+        operations,
+      }),
+    });
+    if (pointer.value !== null) {
+      const content: AutoBeOpenApi.IOperation[] = pointer.value.content.map(
+        (op) => ({
+          ...op,
+          authorizationType: null,
+        }),
+      );
+      ctx.dispatch({
+        type: SOURCE,
+        id: v7(),
+        operations: content,
+        review: pointer.value.think.review,
+        plan: pointer.value.think.plan,
+        content,
+        metric: result.metric,
+        tokenUsage: result.tokenUsage,
+        created_at: new Date().toISOString(),
+        step: ctx.state().analyze?.step ?? 0,
+        total: progress.total,
+        completed: ++progress.completed,
+      } satisfies AutoBeInterfaceOperationReviewEvent);
+      return out(result)(content);
+    }
+    return out(result)(null);
+  });
+}
+
+function createReviewController<Model extends ILlmSchema.Model>(props: {
+  model: Model;
+  preliminary: AutoBePreliminaryController<"analysisFiles" | "prismaSchemas">;
+  prismaSchemas: AutoBePrisma.IFile[];
+  build: (
+    reviews: IAutoBeInterfaceOperationReviewApplication.IComplete,
+  ) => void;
+}): IAgenticaController.IClass<Model> {
+  const validate = (
+    next: unknown,
+  ): IValidation<IAutoBeInterfaceOperationReviewApplication.IProps> => {
+    const result: IValidation<IAutoBeInterfaceOperationReviewApplication.IProps> =
+      typia.validate<IAutoBeInterfaceOperationReviewApplication.IProps>(next);
+    if (result.success === false) return result;
+    else if (result.data.request.type !== "complete")
+      return props.preliminary.validate({
+        thinking: result.data.thinking,
+        request: result.data.request,
+      });
+
+    const errors: IValidation.IError[] = [];
+    OperationValidator.validate({
+      path: "$input.request.content",
+      operations: result.data.request.content,
+      errors,
+    });
+    if (errors.length !== 0)
+      return {
+        success: false,
+        errors,
+        data: next,
+      };
+    return result;
+  };
+  const application: ILlmApplication<Model> = collection[
+    props.model === "chatgpt"
+      ? "chatgpt"
+      : props.model === "gemini"
+        ? "gemini"
+        : "claude"
+  ](
+    validate,
+  ) satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
+
+  return {
+    protocol: "class",
+    name: SOURCE,
+    application,
+    execute: {
+      process: (next) => {
+        if (next.request.type === "complete") props.build(next.request);
+      },
+    } satisfies IAutoBeInterfaceOperationReviewApplication,
+  };
+}
+
+const collection = {
+  chatgpt: (validate: Validator) =>
+    typia.llm.application<
+      IAutoBeInterfaceOperationReviewApplication,
+      "chatgpt"
+    >({
+      validate: {
+        process: validate,
+      },
+    }),
+  claude: (validate: Validator) =>
+    typia.llm.application<IAutoBeInterfaceOperationReviewApplication, "claude">(
+      {
+        validate: {
+          process: validate,
+        },
+      },
+    ),
+  gemini: (validate: Validator) =>
+    typia.llm.application<IAutoBeInterfaceOperationReviewApplication, "gemini">(
+      {
+        validate: {
+          process: validate,
+        },
+      },
+    ),
+};
+
+type Validator = (
+  input: unknown,
+) => IValidation<IAutoBeInterfaceOperationReviewApplication.IProps>;
+
+const SOURCE = "interfaceOperationReview" satisfies AutoBeEventSource;