@autobe/agent 0.28.1 → 0.29.0

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

@@ -0,0 +1,88 @@
+import { AutoBeOpenApi } from "@autobe/interface";
+import { StringUtil } from "@autobe/utils";
+import { v7 } from "uuid";
+
+import { AutoBeState } from "../../../context/AutoBeState";
+import { IAutoBeOrchestrateHistory } from "../../../structures/IAutoBeOrchestrateHistory";
+import { AutoBePreliminaryController } from "../../common/AutoBePreliminaryController";
+
+export const transformInterfaceSchemaReviewHistory = (props: {
+  state: AutoBeState;
+  systemPrompt: string;
+  instruction: string;
+  preliminary: AutoBePreliminaryController<
+    | "analysisFiles"
+    | "prismaSchemas"
+    | "interfaceOperations"
+    | "interfaceSchemas"
+  >;
+  reviewOperations: AutoBeOpenApi.IOperation[];
+  reviewSchemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>;
+}): IAutoBeOrchestrateHistory => {
+  return {
+    histories: [
+      {
+        type: "systemMessage",
+        id: v7(),
+        created_at: new Date().toISOString(),
+        text: props.systemPrompt,
+      },
+      ...props.preliminary.getHistories(),
+      {
+        type: "assistantMessage",
+        id: v7(),
+        created_at: new Date().toISOString(),
+        text: StringUtil.trim`
+          ## API Design Instructions
+
+          The following API-specific instructions were extracted from
+          the user's requirements. These focus on API interface design aspects
+          relevant to the review task.
+
+          Follow these instructions when reviewing and fixing schemas.
+          Carefully distinguish between:
+          - Suggestions or recommendations (consider these as guidance)
+          - Direct specifications or explicit commands (these must be followed exactly)
+
+          When instructions contain direct specifications or explicit design decisions,
+          follow them precisely even if you believe you have better alternatives.
+
+          ${props.instruction}
+        `,
+      },
+      {
+        id: v7(),
+        type: "assistantMessage",
+        created_at: new Date().toISOString(),
+        text: StringUtil.trim`
+          ## Schemas Needing Review
+
+          From the complete schema set above, here are the SPECIFIC schemas that need review:
+
+          \`\`\`json
+          ${JSON.stringify(props.reviewSchemas)}
+          \`\`\`
+
+          IMPORTANT: Only these ${Object.keys(props.reviewSchemas).length} schemas
+          need review and potential modification. The other schemas in
+          the full set are provided for reference only.
+
+          ## Operations (Filtered for Target Schemas)
+
+          Here are the API operations that directly use the schemas under review.
+          These operations reference at least one of the target schemas via
+          requestBody.typeName or responseBody.typeName.
+
+          This FILTERED list helps you understand the exact usage context for
+          the schemas you're reviewing:
+
+          \`\`\`json
+          ${JSON.stringify(props.reviewOperations)}
+          \`\`\`
+        `,
+      },
+    ],
+    userMessage: "Review and fix the schemas please",
+    // "Review DTO content completeness and consistency."
+  };
+};

package/src/orchestrate/interface/orchestrateInterface.ts

@@ -22,16 +22,17 @@ import { AutoBeSystemPromptConstant } from "../../constants/AutoBeSystemPromptCo
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { predicateStateMessage } from "../../utils/predicateStateMessage";
 import { IAutoBeFacadeApplicationProps } from "../facade/histories/IAutoBeFacadeApplicationProps";
-import { orchestrateInterfaceAuthorizations } from "./orchestrateInterfaceAuthorizations";
+import { orchestrateInterfaceAuthorization } from "./orchestrateInterfaceAuthorization";
 import { orchestrateInterfaceComplement } from "./orchestrateInterfaceComplement";
-import { orchestrateInterfaceEndpoints } from "./orchestrateInterfaceEndpoints";
-import { orchestrateInterfaceGroups } from "./orchestrateInterfaceGroups";
-import { orchestrateInterfaceOperations } from "./orchestrateInterfaceOperations";
-import { orchestrateInterfacePrerequisites } from "./orchestrateInterfacePrerequisites";
+import { orchestrateInterfaceEndpoint } from "./orchestrateInterfaceEndpoint";
+import { orchestrateInterfaceGroup } from "./orchestrateInterfaceGroup";
+import { orchestrateInterfaceOperation } from "./orchestrateInterfaceOperation";
+import { orchestrateInterfacePrerequisite } from "./orchestrateInterfacePrerequisite";
+import { orchestrateInterfaceSchema } from "./orchestrateInterfaceSchema";
 import { orchestrateInterfaceSchemaRename } from "./orchestrateInterfaceSchemaRename";
 import { orchestrateInterfaceSchemaReview } from "./orchestrateInterfaceSchemaReview";
-import { orchestrateInterfaceSchemas } from "./orchestrateInterfaceSchemas";
 import { JsonSchemaFactory } from "./utils/JsonSchemaFactory";
+import { JsonSchemaNamingConvention } from "./utils/JsonSchemaNamingConvention";
 
 export const orchestrateInterface =
   <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>) =>
@@ -60,8 +61,11 @@ export const orchestrateInterface =
       step: ctx.state().analyze?.step ?? 0,
     });
 
+    //------------------------------------------------
+    // OPERATIONS
+    //------------------------------------------------
     // ENDPOINTS
-    const init: AutoBeInterfaceGroupEvent = await orchestrateInterfaceGroups(
+    const init: AutoBeInterfaceGroupEvent = await orchestrateInterfaceGroup(
       ctx,
       {
         instruction: props.instruction,
@@ -71,20 +75,22 @@ export const orchestrateInterface =
 
     // AUTHORIZATION
     const authorizations: AutoBeInterfaceAuthorization[] =
-      await orchestrateInterfaceAuthorizations(ctx, props.instruction);
+      await orchestrateInterfaceAuthorization(ctx, {
+        instruction: props.instruction,
+      });
     const authOperations: AutoBeOpenApi.IOperation[] = authorizations
       .map((authorization) => authorization.operations)
       .flat();
 
     // ENDPOINTS & OPERATIONS
     const endpoints: AutoBeOpenApi.IEndpoint[] =
-      await orchestrateInterfaceEndpoints(ctx, {
+      await orchestrateInterfaceEndpoint(ctx, {
         groups: init.groups,
         authorizations: authOperations,
         instruction: props.instruction,
       });
     const firstOperations: AutoBeOpenApi.IOperation[] =
-      await orchestrateInterfaceOperations(ctx, {
+      await orchestrateInterfaceOperation(ctx, {
         endpoints,
         instruction: props.instruction,
       });
@@ -108,72 +114,115 @@ export const orchestrateInterface =
       .toJSON()
       .map((it) => it.second);
 
-    // TYPE SCHEMAS
+    // THE DOCUMENT
     const document: AutoBeOpenApi.IDocument = {
       operations,
       components: {
         authorizations: ctx.state().analyze?.actors ?? [],
-        schemas: await orchestrateInterfaceSchemas(ctx, {
-          instruction: props.instruction,
-          operations,
-        }),
+        schemas: {},
       },
     };
 
+    //------------------------------------------------
+    // DTO SCHEMAS
+    //------------------------------------------------
     const assign = (
       schemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>,
-    ) => Object.assign(document.components.schemas, schemas);
-    const complement = async () =>
-      assign(
-        await orchestrateInterfaceComplement(ctx, {
-          instruction: props.instruction,
-          document,
-        }),
+    ) => {
+      Object.assign(document.components.schemas, schemas);
+      JsonSchemaFactory.authorize(document.components.schemas);
+      Object.assign(
+        document.components.schemas,
+        JsonSchemaFactory.presets(
+          new Set(Object.keys(document.components.schemas)),
+        ),
       );
-    await complement();
+      JsonSchemaNamingConvention.schemas(
+        document.operations,
+        document.components.schemas,
+      );
+      JsonSchemaFactory.finalize({
+        document,
+        application: ctx.state().prisma!.result.data,
+      });
+    };
 
+    // INITIAL SCHEMAS
+    assign(
+      await orchestrateInterfaceSchema(ctx, {
+        instruction: props.instruction,
+        operations,
+      }),
+    );
+
+    // REVIEW GENERATED
     const reviewProgress: AutoBeProgressEventBase = {
       completed: 0,
-      total: Math.ceil(
-        Object.keys(document.components.schemas).length /
-          AutoBeConfigConstant.INTERFACE_CAPACITY,
-      ),
+      total: 0,
     };
-    for (const config of [
-      {
-        kind: "security" as const,
-        systemPrompt:
-          AutoBeSystemPromptConstant.INTERFACE_SCHEMA_SECURITY_REVIEW,
-      },
-      {
-        kind: "relation" as const,
-        systemPrompt:
-          AutoBeSystemPromptConstant.INTERFACE_SCHEMA_RELATION_REVIEW,
-      },
-      {
-        kind: "content" as const,
-        systemPrompt:
-          AutoBeSystemPromptConstant.INTERFACE_SCHEMA_CONTENT_REVIEW,
-      },
-    ])
+    for (const config of REVIEWERS) {
+      reviewProgress.total = Math.ceil(
+        (Object.keys(document.components.schemas).length * REVIEWERS.length) /
+          AutoBeConfigConstant.INTERFACE_CAPACITY,
+      );
       assign(
         await orchestrateInterfaceSchemaReview(ctx, config, {
           instruction: props.instruction,
           document,
+          schemas: document.components.schemas,
           progress: reviewProgress,
         }),
       );
-    if (missedOpenApiSchemas(document).length !== 0) await complement();
+    }
 
+    // COMPLEMENTATION
+    const complementProgress: AutoBeProgressEventBase = {
+      completed: 0,
+      total: 0,
+    };
+    while (missedOpenApiSchemas(document).length !== 0) {
+      // COMPLEMENT OMITTED
+      const oldbie: Set<string> = new Set(
+        Object.keys(document.components.schemas),
+      );
+      const complemented: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> =
+        await orchestrateInterfaceComplement(ctx, {
+          instruction: props.instruction,
+          progress: complementProgress,
+          document,
+        });
+      const newbie: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> =
+        Object.fromEntries(
+          Object.keys(complemented)
+            .filter((key) => oldbie.has(key) === false)
+            .map((key) => [key, complemented[key]]),
+        );
+      assign(complemented);
+
+      // REVIEW COMPLEMENTED
+      for (const config of REVIEWERS) {
+        reviewProgress.total = Math.ceil(
+          (Object.keys(document.components.schemas).length * REVIEWERS.length) /
+            AutoBeConfigConstant.INTERFACE_CAPACITY,
+        );
+        assign(
+          await orchestrateInterfaceSchemaReview(ctx, config, {
+            instruction: props.instruction,
+            document,
+            schemas: newbie,
+            progress: reviewProgress,
+          }),
+        );
+      }
+    }
     await orchestrateInterfaceSchemaRename(ctx, document);
-    JsonSchemaFactory.finalize({
-      document,
-      application: ctx.state().prisma!.result.data,
-    });
 
-    // CONNECT PRE-REQUISITES
+    //------------------------------------------------
+    // FINALIZATION
+    //------------------------------------------------
+    // CONNECT PREREQUISITES
     const prerequisites: AutoBeInterfacePrerequisite[] =
-      await orchestrateInterfacePrerequisites(ctx, document);
+      await orchestrateInterfacePrerequisite(ctx, document);
     document.operations.forEach((op) => {
       op.prerequisites =
         prerequisites.find(
@@ -197,3 +246,18 @@ export const orchestrateInterface =
       created_at: new Date().toISOString(),
     } satisfies AutoBeInterfaceCompleteEvent);
   };
+
+const REVIEWERS = [
+  {
+    kind: "relation" as const,
+    systemPrompt: AutoBeSystemPromptConstant.INTERFACE_SCHEMA_RELATION_REVIEW,
+  },
+  {
+    kind: "content" as const,
+    systemPrompt: AutoBeSystemPromptConstant.INTERFACE_SCHEMA_CONTENT_REVIEW,
+  },
+  {
+    kind: "security" as const,
+    systemPrompt: AutoBeSystemPromptConstant.INTERFACE_SCHEMA_SECURITY_REVIEW,
+  },
+];

package/src/orchestrate/interface/{orchestrateInterfaceAuthorizations.ts → orchestrateInterfaceAuthorization.ts}

@@ -1,6 +1,7 @@
 import { IAgenticaController } from "@agentica/core";
 import {
   AutoBeAnalyzeActor,
+  AutoBeEventSource,
   AutoBeInterfaceAuthorization,
   AutoBeOpenApi,
   AutoBeProgressEventBase,
@@ -15,14 +16,17 @@ import { v7 } from "uuid";
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
 import { executeCachedBatch } from "../../utils/executeCachedBatch";
-import { transformInterfaceAuthorizationsHistories } from "./histories/transformInterfaceAuthorizationsHistories";
+import { AutoBePreliminaryController } from "../common/AutoBePreliminaryController";
+import { transformInterfaceAuthorizationHistory } from "./histories/transformInterfaceAuthorizationHistory";
 import { IAutoBeInterfaceAuthorizationsApplication } from "./structures/IAutoBeInterfaceAuthorizationsApplication";
 
-export async function orchestrateInterfaceAuthorizations<
+export async function orchestrateInterfaceAuthorization<
   Model extends ILlmSchema.Model,
 >(
   ctx: AutoBeContext<Model>,
-  instruction: string,
+  props: {
+    instruction: string;
+  },
 ): Promise<AutoBeInterfaceAuthorization[]> {
   const actors: AutoBeAnalyzeActor[] = ctx.state().analyze?.actors ?? [];
   const progress: AutoBeProgressEventBase = {
@@ -31,12 +35,13 @@ export async function orchestrateInterfaceAuthorizations<
   };
   const authorizations: AutoBeInterfaceAuthorization[] =
     await executeCachedBatch(
+      ctx,
       actors.map((a) => async (promptCacheKey) => {
         const event: AutoBeInterfaceAuthorizationEvent = await process(ctx, {
           actor: a,
           progress,
           promptCacheKey,
-          instruction,
+          instruction: props.instruction,
         });
         ctx.dispatch(event);
         return {
@@ -45,7 +50,6 @@ export async function orchestrateInterfaceAuthorizations<
         };
       }),
     );
-
   return authorizations;
 }
 
@@ -58,48 +62,62 @@ async function process<Model extends ILlmSchema.Model>(
     promptCacheKey: string;
   },
 ): Promise<AutoBeInterfaceAuthorizationEvent> {
-  const pointer: IPointer<IAutoBeInterfaceAuthorizationsApplication.IProps | null> =
-    {
-      value: null,
-    };
-  const { metric, tokenUsage } = await ctx.conversate({
-    source: "interfaceAuthorization",
-    histories: transformInterfaceAuthorizationsHistories({
-      state: ctx.state(),
-      instruction: props.instruction,
-      actor: props.actor,
-    }),
-    controller: createController({
-      model: ctx.model,
-      actor: props.actor,
-      build: (next) => {
-        pointer.value = next;
-      },
-    }),
-    enforceFunctionCall: true,
-    promptCacheKey: props.promptCacheKey,
-    message: "Create Authorization Operation for the given roles",
+  const preliminary: AutoBePreliminaryController<
+    "analysisFiles" | "prismaSchemas"
+  > = new AutoBePreliminaryController({
+    application:
+      typia.json.application<IAutoBeInterfaceAuthorizationsApplication>(),
+    source: SOURCE,
+    kinds: ["analysisFiles", "prismaSchemas"],
+    state: ctx.state(),
+  });
+  return await preliminary.orchestrate(ctx, async (out) => {
+    const pointer: IPointer<IAutoBeInterfaceAuthorizationsApplication.IComplete | null> =
+      {
+        value: null,
+      };
+    const result: AutoBeContext.IResult<Model> = await ctx.conversate({
+      source: SOURCE,
+      controller: createController({
+        model: ctx.model,
+        actor: props.actor,
+        build: (next) => {
+          pointer.value = next;
+        },
+        preliminary,
+      }),
+      enforceFunctionCall: true,
+      promptCacheKey: props.promptCacheKey,
+      ...transformInterfaceAuthorizationHistory({
+        state: ctx.state(),
+        instruction: props.instruction,
+        actor: props.actor,
+        preliminary,
+      }),
+    });
+    return out(result)(
+      pointer.value !== null
+        ? ({
+            type: SOURCE,
+            id: v7(),
+            operations: pointer.value.operations,
+            completed: ++props.progress.completed,
+            metric: result.metric,
+            tokenUsage: result.tokenUsage,
+            created_at: new Date().toISOString(),
+            step: ctx.state().analyze?.step ?? 0,
+            total: props.progress.total,
+          } satisfies AutoBeInterfaceAuthorizationEvent)
+        : null,
+    );
   });
-  if (pointer.value === null)
-    throw new Error("Failed to generate authorization operation.");
-
-  return {
-    type: "interfaceAuthorization",
-    id: v7(),
-    operations: pointer.value.operations,
-    completed: ++props.progress.completed,
-    metric,
-    tokenUsage,
-    created_at: new Date().toISOString(),
-    step: ctx.state().analyze?.step ?? 0,
-    total: props.progress.total,
-  } satisfies AutoBeInterfaceAuthorizationEvent;
 }
 
 function createController<Model extends ILlmSchema.Model>(props: {
   model: Model;
   actor: AutoBeAnalyzeActor;
-  build: (next: IAutoBeInterfaceAuthorizationsApplication.IProps) => void;
+  preliminary: AutoBePreliminaryController<"analysisFiles" | "prismaSchemas">;
+  build: (next: IAutoBeInterfaceAuthorizationsApplication.IComplete) => void;
 }): IAgenticaController.IClass<Model> {
   assertSchemaModel(props.model);
 
@@ -109,16 +127,20 @@ function createController<Model extends ILlmSchema.Model>(props: {
     const result: IValidation<IAutoBeInterfaceAuthorizationsApplication.IProps> =
       typia.validate<IAutoBeInterfaceAuthorizationsApplication.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,
+      });
     // remove login operation for guest role
-    if (props.actor.kind === "guest") {
-      result.data.operations = result.data.operations.filter(
+    else if (props.actor.kind === "guest") {
+      result.data.request.operations = result.data.request.operations.filter(
         (op) => op.authorizationType !== "login",
       );
     }
 
     const errors: IValidation.IError[] = [];
-    result.data.operations.forEach((op, i) => {
+    result.data.request.operations.forEach((op, i) => {
       // validate authorizationActor
       if (op.authorizationActor !== null) {
         op.authorizationActor = props.actor.name;
@@ -128,7 +150,7 @@ function createController<Model extends ILlmSchema.Model>(props: {
       if (op.authorizationType === null) return;
       else if (op.responseBody === null)
         errors.push({
-          path: `$input.operations.${i}.responseBody`,
+          path: `$input.request.operations.${i}.responseBody`,
           expected:
             "Response body with I{RoleName(PascalCase)}.IAuthorized type is required",
           value: op.responseBody,
@@ -142,7 +164,7 @@ function createController<Model extends ILlmSchema.Model>(props: {
         });
       else if (!op.responseBody.typeName.endsWith(".IAuthorized"))
         errors.push({
-          path: `$input.operations.${i}.responseBody.typeName`,
+          path: `$input.request.operations.${i}.responseBody.typeName`,
           expected: `Type name must be I{RoleName(PascalCase)}.IAuthorized`,
           value: op.responseBody?.typeName,
           description: StringUtil.trim`
@@ -161,7 +183,7 @@ function createController<Model extends ILlmSchema.Model>(props: {
       AutoBeOpenApi.IOperation["authorizationType"]
     >;
     const authorizationTypes: Set<AuthorizationType> = new Set(
-      result.data.operations
+      result.data.request.operations
         .map((o) => o.authorizationType)
         .filter((v) => v !== null),
     );
@@ -169,21 +191,21 @@ function createController<Model extends ILlmSchema.Model>(props: {
       if (props.actor.kind === "guest" && type === "login") continue;
       else if (authorizationTypes.has(type) === false)
         errors.push({
-          path: "$input.operations[].authorizationType",
+          path: "$input.request.operations[].authorizationType",
           expected: StringUtil.trim`{
-          ...(AutoBeOpenApi.IOperation data),
-          authorizationType: "${type}"
-        }`,
+            ...(AutoBeOpenApi.IOperation data),
+            authorizationType: "${type}"
+          }`,
           value: `No authorizationType "${type}" found in any operation`,
           description: StringUtil.trim`
-          There must be an operation that has defined AutoBeOpenApi.IOperation.authorizationType := "${type}"
-          for the "${props.actor}" role's authorization activity; "${type}".
+            There must be an operation that has defined AutoBeOpenApi.IOperation.authorizationType := "${type}"
+            for the "${props.actor}" role's authorization activity; "${type}".
 
-          However, none of the operations have the AutoBeOpenApi.IOperation.authorizationType := "${type}"
-          value, so that the "${props.actor}" cannot perform the authorization ${type} activity.
+            However, none of the operations have the AutoBeOpenApi.IOperation.authorizationType := "${type}"
+            value, so that the "${props.actor}" cannot perform the authorization ${type} activity.
 
-          Please make that operation at the next function calling. You have to do it.
-        `,
+            Please make that operation at the next function calling. You have to do it.
+          `,
         });
     if (errors.length !== 0) {
       return {
@@ -207,35 +229,35 @@ function createController<Model extends ILlmSchema.Model>(props: {
 
   return {
     protocol: "class",
-    name: "Create Authorization Interface",
+    name: SOURCE,
     application,
     execute: {
-      makeOperations: (next) => {
-        props.build(next);
+      process: (next) => {
+        if (next.request.type === "complete") props.build(next.request);
       },
     } satisfies IAutoBeInterfaceAuthorizationsApplication,
   };
 }
 
 const collection = {
-  chatgpt: (validate: Validator) =>
+  chatgpt: (validator: Validator) =>
     typia.llm.application<IAutoBeInterfaceAuthorizationsApplication, "chatgpt">(
       {
         validate: {
-          makeOperations: validate,
+          process: validator,
         },
       },
     ),
-  claude: (validate: Validator) =>
+  claude: (validator: Validator) =>
     typia.llm.application<IAutoBeInterfaceAuthorizationsApplication, "claude">({
       validate: {
-        makeOperations: validate,
+        process: validator,
       },
     }),
-  gemini: (validate: Validator) =>
+  gemini: (validator: Validator) =>
     typia.llm.application<IAutoBeInterfaceAuthorizationsApplication, "gemini">({
       validate: {
-        makeOperations: validate,
+        process: validator,
       },
     }),
 };
@@ -243,3 +265,5 @@ const collection = {
 type Validator = (
   input: unknown,
 ) => IValidation<IAutoBeInterfaceAuthorizationsApplication.IProps>;
+
+const SOURCE = "interfaceAuthorization" satisfies AutoBeEventSource;