@autobe/agent 0.24.2 → 0.25.1

package/src/orchestrate/interface/orchestrateInterfaceComplement.ts

@@ -1,11 +1,7 @@
 import { IAgenticaController } from "@agentica/core";
 import { AutoBeOpenApi } from "@autobe/interface";
-import {
-  ILlmApplication,
-  ILlmSchema,
-  IValidation,
-  OpenApiTypeChecker,
-} from "@samchon/openapi";
+import { missedOpenApiSchemas } 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 from "typia";
@@ -22,20 +18,24 @@ import { fulfillJsonSchemaErrorMessages } from "./utils/fulfillJsonSchemaErrorMe
 
 export function orchestrateInterfaceComplement<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
-  document: AutoBeOpenApi.IDocument,
+  props: {
+    instruction: string;
+    document: AutoBeOpenApi.IDocument;
+  },
 ): Promise<Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>> {
-  return step(ctx, document, 8);
+  return step(ctx, props, false);
 }
 
 async function step<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
-  document: AutoBeOpenApi.IDocument,
-  life: number,
+  props: {
+    instruction: string;
+    document: AutoBeOpenApi.IDocument;
+  },
+  wasEmpty: boolean,
 ): Promise<Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>> {
-  const missed: string[] = getMissed(document);
-  if (missed.length === 0 || life < 0) {
-    return document.components.schemas;
-  }
+  const missed: string[] = missedOpenApiSchemas(props.document);
+  if (missed.length === 0) return props.document.components.schemas;
 
   const pointer: IPointer<Record<
     string,
@@ -45,11 +45,12 @@ async function step<Model extends ILlmSchema.Model>(
   };
   const { tokenUsage } = await ctx.conversate({
     source: "interfaceComplement",
-    histories: transformInterfaceComplementHistories(
-      ctx.state(),
-      document,
+    histories: transformInterfaceComplementHistories({
+      state: ctx.state(),
+      instruction: props.instruction,
+      document: props.document,
       missed,
-    ),
+    }),
     controller: createController({
       model: ctx.model,
       build: (next) => {
@@ -83,45 +84,31 @@ async function step<Model extends ILlmSchema.Model>(
     created_at: new Date().toISOString(),
   });
 
+  const empty: boolean = Object.keys(pointer.value).length === 0;
+  if (empty === true && wasEmpty === true)
+    return props.document.components.schemas;
+
   const newSchemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> = {
     ...pointer.value,
-    ...document.components.schemas,
+    ...props.document.components.schemas,
   };
-  JsonSchemaNamingConvention.schemas(document.operations, newSchemas);
+  JsonSchemaNamingConvention.schemas(props.document.operations, newSchemas);
   return step(
     ctx,
     {
-      ...document,
-      components: {
-        ...document.components,
-        schemas: newSchemas,
+      instruction: props.instruction,
+      document: {
+        ...props.document,
+        components: {
+          ...props.document.components,
+          schemas: newSchemas,
+        },
       },
     },
-    life - 1,
+    empty,
   );
 }
 
-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 createController<Model extends ILlmSchema.Model>(props: {
   model: Model;
   build: (
@@ -133,7 +120,7 @@ function createController<Model extends ILlmSchema.Model>(props: {
   const validate = (
     next: unknown,
   ): IValidation<IAutoBeInterfaceComplementApplication.IProps> => {
-    JsonSchemaFactory.fix("schemas", next);
+    JsonSchemaFactory.fixPage("schemas", next);
 
     const result: IValidation<IAutoBeInterfaceComplementApplication.IProps> =
       typia.validate<IAutoBeInterfaceComplementApplication.IProps>(next);

package/src/orchestrate/interface/orchestrateInterfaceEndpoints.ts

@@ -5,6 +5,7 @@ import {
   AutoBeProgressEventBase,
 } from "@autobe/interface";
 import { AutoBeInterfaceGroup } from "@autobe/interface/src/histories/contents/AutoBeInterfaceGroup";
+import { AutoBeOpenApiEndpointComparator } from "@autobe/utils";
 import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
 import { HashSet, IPointer } from "tstl";
 import typia from "typia";
@@ -16,45 +17,55 @@ import { executeCachedBatch } from "../../utils/executeCachedBatch";
 import { transformInterfaceEndpointHistories } from "./histories/transformInterfaceEndpointHistories";
 import { orchestrateInterfaceEndpointsReview } from "./orchestrateInterfaceEndpointsReview";
 import { IAutoBeInterfaceEndpointApplication } from "./structures/IAutoBeInterfaceEndpointApplication";
-import { OpenApiEndpointComparator } from "./utils/OpenApiEndpointComparator";
 
 export async function orchestrateInterfaceEndpoints<
   Model extends ILlmSchema.Model,
 >(
   ctx: AutoBeContext<Model>,
-  groups: AutoBeInterfaceGroup[],
-  authorizations: AutoBeOpenApi.IOperation[],
-  content: string = `Make endpoints for the given assets`,
+  props: {
+    groups: AutoBeInterfaceGroup[];
+    authorizations: AutoBeOpenApi.IOperation[];
+    instruction: string;
+    message?: string;
+  },
 ): Promise<AutoBeOpenApi.IEndpoint[]> {
   const progress: AutoBeProgressEventBase = {
-    total: groups.length,
+    total: props.groups.length,
     completed: 0,
   };
   const endpoints: AutoBeOpenApi.IEndpoint[] = (
     await executeCachedBatch(
-      groups.map(
-        (g) => (promptCacheKey) =>
-          process(ctx, g, content, progress, authorizations, promptCacheKey),
+      props.groups.map(
+        (group) => (promptCacheKey) =>
+          process(ctx, {
+            group,
+            authorizations: props.authorizations,
+            instruction: props.instruction,
+            message: props.message ?? "Make endpoints for the given assets.",
+            progress,
+            promptCacheKey,
+          }),
       ),
     )
   ).flat();
-
   const deduplicated: AutoBeOpenApi.IEndpoint[] = new HashSet(
     endpoints,
-    OpenApiEndpointComparator.hashCode,
-    OpenApiEndpointComparator.equals,
+    AutoBeOpenApiEndpointComparator.hashCode,
+    AutoBeOpenApiEndpointComparator.equals,
   ).toJSON();
-
   return orchestrateInterfaceEndpointsReview(ctx, deduplicated);
 }
 
 async function process<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
-  group: AutoBeInterfaceGroup,
-  message: string,
-  progress: AutoBeProgressEventBase,
-  authorizations: AutoBeOpenApi.IOperation[],
-  promptCacheKey: string,
+  props: {
+    group: AutoBeInterfaceGroup;
+    message: string;
+    progress: AutoBeProgressEventBase;
+    authorizations: AutoBeOpenApi.IOperation[];
+    promptCacheKey: string;
+    instruction: string;
+  },
 ): Promise<AutoBeOpenApi.IEndpoint[]> {
   const start: Date = new Date();
   const pointer: IPointer<AutoBeOpenApi.IEndpoint[] | null> = {
@@ -62,11 +73,12 @@ async function process<Model extends ILlmSchema.Model>(
   };
   const { tokenUsage } = await ctx.conversate({
     source: "interfaceEndpoints",
-    histories: transformInterfaceEndpointHistories(
-      ctx.state(),
-      group,
-      authorizations,
-    ),
+    histories: transformInterfaceEndpointHistories({
+      state: ctx.state(),
+      group: props.group,
+      authorizations: props.authorizations,
+      instruction: props.instruction,
+    }),
     controller: createController({
       model: ctx.model,
       build: (endpoints) => {
@@ -75,8 +87,8 @@ async function process<Model extends ILlmSchema.Model>(
       },
     }),
     enforceFunctionCall: true,
-    promptCacheKey,
-    message,
+    promptCacheKey: props.promptCacheKey,
+    message: props.message,
   });
   if (pointer.value === null) throw new Error("Failed to generate endpoints."); // unreachable
 
@@ -85,14 +97,14 @@ async function process<Model extends ILlmSchema.Model>(
     id: v7(),
     endpoints: new HashSet(
       pointer.value,
-      OpenApiEndpointComparator.hashCode,
-      OpenApiEndpointComparator.equals,
+      AutoBeOpenApiEndpointComparator.hashCode,
+      AutoBeOpenApiEndpointComparator.equals,
     ).toJSON(),
     tokenUsage,
     created_at: start.toISOString(),
     step: ctx.state().analyze?.step ?? 0,
-    completed: ++progress.completed,
-    total: progress.total,
+    completed: ++props.progress.completed,
+    total: props.progress.total,
   };
   ctx.dispatch(event);
   return pointer.value;

package/src/orchestrate/interface/orchestrateInterfaceGroups.ts

@@ -14,7 +14,10 @@ export async function orchestrateInterfaceGroups<
   Model extends ILlmSchema.Model,
 >(
   ctx: AutoBeContext<Model>,
-  message: string = "Design API operations for the given assets.",
+  props: {
+    instruction: string;
+    message?: string;
+  },
 ): Promise<AutoBeInterfaceGroupsEvent> {
   const start: Date = new Date();
   const pointer: IPointer<IAutoBeInterfaceGroupApplication.IProps | null> = {
@@ -22,7 +25,10 @@ export async function orchestrateInterfaceGroups<
   };
   const { tokenUsage } = await ctx.conversate({
     source: "interfaceGroups",
-    histories: transformInterfaceGroupHistories(ctx.state()),
+    histories: transformInterfaceGroupHistories({
+      state: ctx.state(),
+      instruction: props.instruction,
+    }),
     controller: createController({
       model: ctx.model,
       build: (next) => {
@@ -30,7 +36,7 @@ export async function orchestrateInterfaceGroups<
       },
     }),
     enforceFunctionCall: true,
-    message,
+    message: props.message ?? "Design API operations for the given assets.",
   });
   if (pointer.value === null) throw new Error("Failed to generate groups."); // unreachable
   return {

package/src/orchestrate/interface/orchestrateInterfaceOperations.ts

@@ -4,7 +4,7 @@ import {
   AutoBeOpenApi,
   AutoBeProgressEventBase,
 } from "@autobe/interface";
-import { StringUtil } from "@autobe/utils";
+import { AutoBeOpenApiEndpointComparator, StringUtil } from "@autobe/utils";
 import { ILlmApplication, ILlmSchema, IValidation } from "@samchon/openapi";
 import { HashMap, HashSet, IPointer } from "tstl";
 import typia from "typia";
@@ -19,21 +19,22 @@ import { executeCachedBatch } from "../../utils/executeCachedBatch";
 import { transformInterfaceOperationHistories } from "./histories/transformInterfaceOperationHistories";
 import { orchestrateInterfaceOperationsReview } from "./orchestrateInterfaceOperationsReview";
 import { IAutoBeInterfaceOperationApplication } from "./structures/IAutoBeInterfaceOperationApplication";
-import { OpenApiEndpointComparator } from "./utils/OpenApiEndpointComparator";
 import { OperationValidator } from "./utils/OperationValidator";
 
 export async function orchestrateInterfaceOperations<
   Model extends ILlmSchema.Model,
 >(
   ctx: AutoBeContext<Model>,
-  endpoints: AutoBeOpenApi.IEndpoint[],
-  capacity: number = AutoBeConfigConstant.INTERFACE_CAPACITY,
+  props: {
+    instruction: string;
+    endpoints: AutoBeOpenApi.IEndpoint[];
+    capacity?: number;
+  },
 ): Promise<AutoBeOpenApi.IOperation[]> {
   const matrix: AutoBeOpenApi.IEndpoint[][] = divideArray({
-    array: endpoints,
-    capacity,
+    array: props.endpoints,
+    capacity: props.capacity ?? AutoBeConfigConstant.INTERFACE_CAPACITY,
   });
-
   const progress: AutoBeProgressEventBase = {
     total: matrix.flat().length,
     completed: 0,
@@ -45,13 +46,13 @@ export async function orchestrateInterfaceOperations<
   return (
     await executeCachedBatch(
       matrix.map((it) => async (promptCacheKey) => {
-        const row: AutoBeOpenApi.IOperation[] = await divideAndConquer(
-          ctx,
-          it,
+        const row: AutoBeOpenApi.IOperation[] = await divideAndConquer(ctx, {
+          endpoints: it,
           progress,
           reviewProgress,
           promptCacheKey,
-        );
+          instruction: props.instruction,
+        });
         return row;
       }),
     )
@@ -60,25 +61,34 @@ export async function orchestrateInterfaceOperations<
 
 async function divideAndConquer<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
-  endpoints: AutoBeOpenApi.IEndpoint[],
-  operationsProgress: AutoBeProgressEventBase,
-  operationsReviewProgress: AutoBeProgressEventBase,
-  promptCacheKey: string,
+  props: {
+    endpoints: AutoBeOpenApi.IEndpoint[];
+    progress: AutoBeProgressEventBase;
+    reviewProgress: AutoBeProgressEventBase;
+    promptCacheKey: string;
+    instruction: string;
+  },
 ): Promise<AutoBeOpenApi.IOperation[]> {
   const remained: HashSet<AutoBeOpenApi.IEndpoint> = new HashSet(
-    endpoints,
-    OpenApiEndpointComparator.hashCode,
-    OpenApiEndpointComparator.equals,
+    props.endpoints,
+    AutoBeOpenApiEndpointComparator.hashCode,
+    AutoBeOpenApiEndpointComparator.equals,
   );
   const unique: HashMap<AutoBeOpenApi.IEndpoint, AutoBeOpenApi.IOperation> =
     new HashMap(
-      OpenApiEndpointComparator.hashCode,
-      OpenApiEndpointComparator.equals,
+      AutoBeOpenApiEndpointComparator.hashCode,
+      AutoBeOpenApiEndpointComparator.equals,
     );
   for (let i: number = 0; i < ctx.retry; ++i) {
-    if (remained.empty() === true || unique.size() >= endpoints.length) break;
+    if (remained.empty() === true || unique.size() >= props.endpoints.length)
+      break;
     const operations: AutoBeOpenApi.IOperation[] = remained.size()
-      ? await process(ctx, remained, operationsProgress, promptCacheKey)
+      ? await process(ctx, {
+          endpoints: remained,
+          progress: props.progress,
+          promptCacheKey: props.promptCacheKey,
+          instruction: props.instruction,
+        })
       : [];
 
     for (const item of operations) {
@@ -90,7 +100,7 @@ async function divideAndConquer<Model extends ILlmSchema.Model>(
     await orchestrateInterfaceOperationsReview(
       ctx,
       unique.toJSON().map((it) => it.second),
-      operationsReviewProgress,
+      props.reviewProgress,
     );
   for (const item of newbie) unique.set(item, item);
   return unique.toJSON().map((it) => it.second);
@@ -98,9 +108,12 @@ async function divideAndConquer<Model extends ILlmSchema.Model>(
 
 async function process<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
-  endpoints: HashSet<AutoBeOpenApi.IEndpoint>,
-  progress: AutoBeProgressEventBase,
-  promptCacheKey: string,
+  props: {
+    endpoints: HashSet<AutoBeOpenApi.IEndpoint>;
+    progress: AutoBeProgressEventBase;
+    promptCacheKey: string;
+    instruction: string;
+  },
 ): Promise<AutoBeOpenApi.IOperation[]> {
   const prefix: string = NamingConvention.camel(ctx.state().analyze!.prefix);
   const pointer: IPointer<AutoBeOpenApi.IOperation[] | null> = {
@@ -108,10 +121,11 @@ async function process<Model extends ILlmSchema.Model>(
   };
   const { tokenUsage } = await ctx.conversate({
     source: "interfaceOperations",
-    histories: transformInterfaceOperationHistories(
-      ctx.state(),
-      endpoints.toJSON(),
-    ),
+    histories: transformInterfaceOperationHistories({
+      state: ctx.state(),
+      endpoints: props.endpoints.toJSON(),
+      instruction: props.instruction,
+    }),
     controller: createController({
       model: ctx.model,
       roles: ctx.state().analyze?.roles.map((it) => it.name) ?? [],
@@ -129,6 +143,7 @@ async function process<Model extends ILlmSchema.Model>(
                     .join("/"),
                 authorizationRole: null,
                 authorizationType: null,
+                prerequisites: [],
               },
             ];
           return op.authorizationRoles.map((role) => ({
@@ -140,13 +155,14 @@ async function process<Model extends ILlmSchema.Model>(
                 .join("/"),
             authorizationRole: role,
             authorizationType: null,
+            prerequisites: [],
           }));
         });
         pointer.value.push(...matrix.flat());
-        progress.completed += matrix.flat().length;
-        progress.total += operations
+        props.progress.completed += matrix.flat().length;
+        props.progress.total += operations
           .map((op) =>
-            endpoints.has({ path: op.path, method: op.method })
+            props.endpoints.has({ path: op.path, method: op.method })
               ? op.authorizationRoles.length === 0
                 ? 0
                 : op.authorizationRoles.length - 1
@@ -156,7 +172,7 @@ async function process<Model extends ILlmSchema.Model>(
       },
     }),
     enforceFunctionCall: true,
-    promptCacheKey,
+    promptCacheKey: props.promptCacheKey,
     message: "Make API operations",
   });
   if (pointer.value === null) throw new Error("Failed to create operations."); // never be happened
@@ -166,7 +182,7 @@ async function process<Model extends ILlmSchema.Model>(
     id: v7(),
     operations: pointer.value,
     tokenUsage,
-    ...progress,
+    ...props.progress,
     step: ctx.state().analyze?.step ?? 0,
     created_at: new Date().toISOString(),
   } satisfies AutoBeInterfaceOperationsEvent);