@autobe/agent 0.15.0 → 0.16.0

package/src/factory/getAutoBeGenerated.ts

@@ -92,7 +92,7 @@ export async function getAutoBeGenerated(
     );
 
   // REALIZE
-  if (state.realize?.step === state.analyze.step)
+  if (state.realize?.step === state.analyze.step) {
     Object.assign<Record<string, string>, Record<string, string>>(ret, {
       ...Object.fromEntries(
         state.realize.functions.map((f) => [f.location, f.content]),
@@ -113,6 +113,7 @@ export async function getAutoBeGenerated(
         authorizations: state.realize.authorizations,
       })),
     });
+  }
 
   // LOGGING
   Object.assign<Record<string, string>, Record<string, string>>(ret, {

package/src/orchestrate/analyze/AutoBeAnalyzeFileSystem.ts

@@ -42,17 +42,6 @@ export interface IAutoBeAnalyzeFileSystem {
   createOrUpdateFiles(
     input: ICreateOrUpdateInput,
   ): Promise<Record<string, string>>;
-
-  /**
-   * If you decide that you no longer need any reviews, or if the reviewer
-   * refuses to do so, call abort. This is a function to end document creation
-   * and review, and to respond to users.
-   *
-   * When there is content you are unsure about and need to ask the user a
-   * question, abort the process and ask the user directly. The reason for
-   * aborting should be included as the content of the question.
-   */
-  abort(input: { reason: string }): "OK";
 }
 
 export class AutoBeAnalyzeFileSystem implements IAutoBeAnalyzeFileSystem {
@@ -66,8 +55,4 @@ export class AutoBeAnalyzeFileSystem implements IAutoBeAnalyzeFileSystem {
 
     return this.fileMap;
   }
-
-  abort(_input: { reason: string }): "OK" {
-    return "OK";
-  }
 }

package/src/orchestrate/analyze/orchestrateAnalyze.ts

@@ -8,7 +8,6 @@ import { v4 } from "uuid";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { IAutoBeApplicationProps } from "../../context/IAutoBeApplicationProps";
-import { AutoBeAnalyzePointer } from "./AutoBeAnalyzePointer";
 import { orchestrateAnalyzeComposer } from "./orchestrateAnalyzeComposer";
 import { IComposeInput } from "./structures/IAutoBeAnalyzeComposerApplication";
 import { writeDocumentUntilReviewPassed } from "./writeDocumentUntilReviewPassed";
@@ -28,8 +27,11 @@ export const orchestrateAnalyze =
       created_at,
     });
 
-    const pointer: IPointer<IComposeInput | null> = { value: null };
-    const agentica = orchestrateAnalyzeComposer(ctx, pointer);
+    const composeInputPointer: IPointer<IComposeInput | null> = { value: null };
+    const agentica = orchestrateAnalyzeComposer(ctx, (v) => {
+      composeInputPointer.value = v;
+    });
+
     const determined = await agentica
       .conversate(
         [
@@ -42,7 +44,9 @@ export const orchestrateAnalyze =
         const tokenUsage = agentica.getTokenUsage();
         ctx.usage().record(tokenUsage, ["analyze"]);
       });
-    if (pointer.value === null) {
+
+    const composeInput = composeInputPointer.value;
+    if (composeInput === null) {
       return {
         id: v4(),
         text: "Failed to analyze your request. please request again.",
@@ -52,7 +56,7 @@ export const orchestrateAnalyze =
       };
     }
 
-    const { files: tableOfContents, prefix, roles } = pointer.value;
+    const { files: tableOfContents, prefix, roles } = composeInput;
 
     if (tableOfContents.length === 0) {
       const history: AutoBeAssistantMessageHistory = {
@@ -77,17 +81,13 @@ export const orchestrateAnalyze =
     };
     const pointers = await Promise.all(
       tableOfContents.map(async ({ filename }) => {
-        const pointer: AutoBeAnalyzePointer = { value: { files: {} } };
-        await writeDocumentUntilReviewPassed(
-          ctx,
-          pointer,
-          tableOfContents,
+        return await writeDocumentUntilReviewPassed(ctx, {
+          totalFiles: tableOfContents,
           filename,
           roles,
           progress,
-          retryCount,
-        );
-        return pointer;
+          retry: retryCount,
+        });
       }),
     );
 
@@ -114,7 +114,7 @@ export const orchestrateAnalyze =
       ctx.dispatch({
         type: "analyzeComplete",
         prefix,
-        files: files,
+        files,
         step,
         created_at,
       });
@@ -129,9 +129,9 @@ export const orchestrateAnalyze =
       completed_at: new Date().toISOString(),
     };
     ctx.dispatch({
-      type: "assistantMessage",
-      text: determined.find((el) => el.type === "assistantMessage")?.text ?? "",
-      created_at,
+      type: history.type,
+      text: history.text,
+      created_at: history.created_at,
     });
     return history;
   };

package/src/orchestrate/analyze/orchestrateAnalyzeComposer.ts

@@ -1,6 +1,5 @@
 import { IAgenticaController, MicroAgentica } from "@agentica/core";
 import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
-import { IPointer } from "tstl";
 import typia from "typia";
 import { v4 } from "uuid";
 
@@ -15,14 +14,12 @@ import {
 
 export const orchestrateAnalyzeComposer = <Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
-  pointer: IPointer<IComposeInput | null>,
+  setComposeInput: (value: IComposeInput) => void,
 ) => {
   const controller = createController<Model>({
     model: ctx.model,
     execute: new AutoBeAnalyzeComposerApplication(),
-    build: (value: IComposeInput) => {
-      pointer.value = value;
-    },
+    preExecute: setComposeInput,
   });
 
   const agent = new MicroAgentica({
@@ -78,7 +75,7 @@ class AutoBeAnalyzeComposerApplication
 function createController<Model extends ILlmSchema.Model>(props: {
   model: Model;
   execute: AutoBeAnalyzeComposerApplication;
-  build: (input: IComposeInput) => void;
+  preExecute: (input: IComposeInput) => void;
 }): IAgenticaController.IClass<Model> {
   assertSchemaModel(props.model);
   const application: ILlmApplication<Model> = collection[
@@ -90,7 +87,7 @@ function createController<Model extends ILlmSchema.Model>(props: {
     application,
     execute: {
       compose: (input) => {
-        props.build(input);
+        props.preExecute(input);
         return props.execute.compose(input);
       },
     } satisfies IAutoBeAnalyzeComposerApplication,

package/src/orchestrate/analyze/orchestrateAnalyzeReviewer.ts

@@ -1,10 +1,22 @@
-import { MicroAgentica } from "@agentica/core";
-import { ILlmSchema } from "@samchon/openapi";
+import { IAgenticaController, MicroAgentica } from "@agentica/core";
+import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
+import { IPointer } from "tstl";
+import typia from "typia";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
+import { assertSchemaModel } from "../../context/assertSchemaModel";
 import { enforceToolCall } from "../../utils/enforceToolCall";
 import { transformAnalyzeReviewerHistories } from "./transformAnalyzeReviewerHistories";
 
+export type IOrchestrateAnalyzeReviewerResult =
+  | {
+      type: "reject";
+      value: string;
+    }
+  | {
+      type: "accept";
+    };
+
 export const orchestrateAnalyzeReviewer = async <
   Model extends ILlmSchema.Model,
 >(
@@ -13,11 +25,24 @@ export const orchestrateAnalyzeReviewer = async <
     /** Total file names */
     files: Record<string, string>;
   },
-): Promise<string | null> => {
+): Promise<IOrchestrateAnalyzeReviewerResult> => {
+  const fnCalled: IPointer<IOrchestrateAnalyzeReviewerResult> = {
+    value: {
+      type: "reject",
+      value: "reviewer is not working because of unknown reason.",
+    },
+  };
+
+  const controller = createController({
+    model: ctx.model,
+    setResult: (result: IOrchestrateAnalyzeReviewerResult) => {
+      fnCalled.value = result;
+    },
+  });
   const agent = new MicroAgentica({
     model: ctx.model,
     vendor: ctx.vendor,
-    controllers: [],
+    controllers: [controller],
     config: {
       ...ctx.config,
       executor: {
@@ -29,9 +54,78 @@ export const orchestrateAnalyzeReviewer = async <
   enforceToolCall(agent);
 
   const command = `proceed with the review of these files only.` as const;
-  const histories = await agent.conversate(command).finally(() => {
+  await agent.conversate(command).finally(() => {
     const tokenUsage = agent.getTokenUsage();
     ctx.usage().record(tokenUsage, ["analyze"]);
   });
-  return histories.find((h) => h.type === "assistantMessage")?.text ?? null;
+
+  return fnCalled.value;
+};
+
+interface IAutoBeAnalyzerReviewerSystem {
+  /**
+   * If there is anything that needs to be modified, you can call it, This
+   * function is to reject the document for to try rewriting document with your
+   * advice or suggestion.
+   */
+  reject(input: {
+    /**
+     * The reason why you reject the document and the suggestion for the
+     * modification. You can write the reason in detail.
+     */
+    reason: string;
+  }): "OK" | Promise<"OK">;
+
+  /**
+   * If you decide that you no longer need any reviews, call accept. This is a
+   * function to end document creation and review, and to respond to users.
+   */
+  accept(): "OK" | Promise<"OK">;
+}
+
+function createController<Model extends ILlmSchema.Model>(props: {
+  model: Model;
+  setResult: (result: IOrchestrateAnalyzeReviewerResult) => void;
+}): IAgenticaController.IClass<Model> {
+  assertSchemaModel(props.model);
+  const application: ILlmApplication<Model> = collection[
+    props.model
+  ] as unknown as ILlmApplication<Model>;
+  return {
+    protocol: "class",
+    name: "Reviewer",
+    application,
+    execute: {
+      accept: async () => {
+        props.setResult({
+          type: "accept",
+        });
+        return "OK" as const;
+      },
+      reject: async (input) => {
+        props.setResult({
+          type: "reject",
+          value: input.reason,
+        });
+        return "OK" as const;
+      },
+    } satisfies IAutoBeAnalyzerReviewerSystem,
+  };
+}
+
+const claude = typia.llm.application<
+  IAutoBeAnalyzerReviewerSystem,
+  "claude",
+  { reference: true }
+>();
+const collection = {
+  chatgpt: typia.llm.application<
+    IAutoBeAnalyzerReviewerSystem,
+    "chatgpt",
+    { reference: true }
+  >(),
+  claude,
+  llama: claude,
+  deepseek: claude,
+  "3.1": claude,
 };

package/src/orchestrate/analyze/orchestrateAnalyzeWrite.ts

@@ -1,7 +1,6 @@
 import { IAgenticaController, MicroAgentica } from "@agentica/core";
 import { AutoBeAnalyzeRole } from "@autobe/interface";
 import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
-import { IPointer } from "tstl";
 import typia from "typia";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
@@ -12,10 +11,7 @@ import {
   IAutoBeAnalyzeFileSystem,
   IFile,
 } from "./AutoBeAnalyzeFileSystem";
-import {
-  AutoBEAnalyzeFileMap,
-  AutoBeAnalyzePointer,
-} from "./AutoBeAnalyzePointer";
+import { AutoBEAnalyzeFileMap } from "./AutoBeAnalyzePointer";
 import { transformAnalyzeWriteHistories } from "./transformAnalyzeWriteHistories";
 
 export const orchestrateAnalyzeWrite = <Model extends ILlmSchema.Model>(
@@ -26,18 +22,13 @@ export const orchestrateAnalyzeWrite = <Model extends ILlmSchema.Model>(
     targetFile: string;
     roles: AutoBeAnalyzeRole[];
     review: string | null;
+    setDocument: (v: AutoBEAnalyzeFileMap) => void;
   },
-  pointer: AutoBeAnalyzePointer,
-  isAborted: IPointer<boolean>,
 ): MicroAgentica<Model> => {
   const controller = createController<Model>({
     model: ctx.model,
     execute: new AutoBeAnalyzeFileSystem({ [input.targetFile]: "" as const }),
-    build: async (files: AutoBEAnalyzeFileMap) => {
-      pointer.value ??= { files: {} };
-      Object.assign(pointer.value.files, files);
-    },
-    abort: () => (isAborted.value = true),
+    setDocument: input.setDocument,
   });
 
   const agent = new MicroAgentica({
@@ -59,8 +50,7 @@ export const orchestrateAnalyzeWrite = <Model extends ILlmSchema.Model>(
 function createController<Model extends ILlmSchema.Model>(props: {
   model: Model;
   execute: AutoBeAnalyzeFileSystem;
-  build: (input: AutoBEAnalyzeFileMap) => void;
-  abort: () => void;
+  setDocument: (v: AutoBEAnalyzeFileMap) => void;
 }): IAgenticaController.IClass<Model> {
   assertSchemaModel(props.model);
   const application: ILlmApplication<Model> = collection[
@@ -71,15 +61,9 @@ function createController<Model extends ILlmSchema.Model>(props: {
     name: "Planning",
     application,
     execute: {
-      abort: (input) => {
-        const response = props.execute.abort(input);
-        props.abort();
-
-        return response;
-      },
       createOrUpdateFiles: async (input) => {
         const fileMap = await props.execute.createOrUpdateFiles(input);
-        props.build(fileMap);
+        props.setDocument(fileMap);
         return fileMap;
       },
     } satisfies IAutoBeAnalyzeFileSystem,

package/src/orchestrate/analyze/writeDocumentUntilReviewPassed.ts

@@ -1,10 +1,12 @@
 import { AutoBeAnalyzeRole } from "@autobe/interface";
 import { ILlmSchema } from "@samchon/openapi";
-import { IPointer } from "tstl";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { IFile } from "./AutoBeAnalyzeFileSystem";
-import { AutoBeAnalyzePointer } from "./AutoBeAnalyzePointer";
+import {
+  AutoBEAnalyzeFileMap,
+  AutoBeAnalyzePointer,
+} from "./AutoBeAnalyzePointer";
 import { orchestrateAnalyzeReviewer } from "./orchestrateAnalyzeReviewer";
 import { orchestrateAnalyzeWrite } from "./orchestrateAnalyzeWrite";
 
@@ -12,68 +14,83 @@ export async function writeDocumentUntilReviewPassed<
   Model extends ILlmSchema.Model,
 >(
   ctx: AutoBeContext<Model>,
-  pointer: AutoBeAnalyzePointer,
-  totalFiles: Pick<IFile, "filename" | "reason">[],
-  filename: string,
-  roles: AutoBeAnalyzeRole[],
-  progress: { total: number; completed: number },
-  retry = 3,
+  props: {
+    totalFiles: Pick<IFile, "filename" | "reason">[];
+    filename: string;
+    roles: AutoBeAnalyzeRole[];
+    progress: { total: number; completed: number };
+    retry?: number;
+    prevReview?: string;
+  },
 ): Promise<AutoBeAnalyzePointer> {
-  const isAborted: IPointer<boolean> = { value: false };
-  let review: string | null = null;
-  for (let i = 0; i < retry; i++) {
-    if (isAborted.value === true) {
-      return pointer;
-    }
+  const retry = props.retry ?? 3;
+  const pointer: { value: { files: AutoBEAnalyzeFileMap } } = {
+    value: { files: {} },
+  };
 
-    // Write the document until the review is passed.
-    const write = "Write Document OR Abort." as const;
-    const writer = orchestrateAnalyzeWrite(
-      ctx,
-      {
-        totalFiles: totalFiles,
-        roles: roles,
-        targetFile: filename,
-        review,
-      },
-      pointer,
-      isAborted,
-    );
+  /**
+   * `retry` means the number of times to retry the review. so if `retry` is -1,
+   * it means not execute this logic.
+   */
+  if (retry === -1) {
+    return pointer;
+  }
+
+  let isToolCalled = false;
+  const writer = orchestrateAnalyzeWrite(ctx, {
+    totalFiles: props.totalFiles,
+    roles: props.roles,
+    targetFile: props.filename,
+    review: props.prevReview ?? "",
+    setDocument: (v) => {
+      isToolCalled = true;
+      pointer.value = { files: { ...pointer.value?.files, ...v } };
+    },
+  });
+  await writer.conversate("Write Document.").finally(() => {
+    const tokenUsage = writer.getTokenUsage();
+    ctx.usage().record(tokenUsage, ["analyze"]);
+  });
 
-    await writer.conversate(review ?? write).finally(() => {
-      const tokenUsage = writer.getTokenUsage();
-      ctx.usage().record(tokenUsage, ["analyze"]);
-    });
+  if (isToolCalled === false) {
+    throw new Error("Failed to write document by unknown reason.");
+  }
 
-    if (pointer.value === null) {
-      throw new Error("Failed to write document by unknown reason.");
-    }
+  ctx.dispatch({
+    type: "analyzeWrite",
+    files: {
+      ...pointer.value?.files,
+    },
+    total: props.progress.total,
+    completed: ++props.progress.completed,
+    step: ctx.state().analyze?.step ?? 0,
+    created_at: new Date().toISOString(),
+  });
 
-    ctx.dispatch({
-      type: "analyzeWrite",
-      files: {
-        ...pointer.value.files,
-      },
-      total: progress.total,
-      completed: ++progress.completed,
-      step: ctx.state().analyze?.step ?? 0,
-      created_at: new Date().toISOString(),
-    });
+  const reviewResult = await orchestrateAnalyzeReviewer(ctx, pointer.value);
 
-    // Do review
-    review = await orchestrateAnalyzeReviewer(ctx, pointer.value);
-    if (review !== null)
-      ctx.dispatch({
-        type: "analyzeReview",
-        files: {
-          ...pointer.value.files,
-        },
-        review,
-        total: progress.total,
-        completed: progress.completed,
-        step: ctx.state().analyze?.step ?? 0,
-        created_at: new Date().toISOString(),
-      });
+  if (reviewResult.type === "accept") {
+    return pointer;
   }
-  return pointer;
+
+  ctx.dispatch({
+    type: "analyzeReview",
+    files: {
+      ...pointer.value.files,
+    },
+    review: reviewResult.value,
+    total: props.progress.total,
+    completed: props.progress.completed,
+    step: ctx.state().analyze?.step ?? 0,
+    created_at: new Date().toISOString(),
+  });
+
+  return await writeDocumentUntilReviewPassed(ctx, {
+    totalFiles: props.totalFiles,
+    filename: props.filename,
+    roles: props.roles,
+    progress: props.progress,
+    retry: retry - 1,
+    prevReview: reviewResult.value,
+  });
 }

package/src/orchestrate/prisma/transformPrismaComponentsHistories.ts

@@ -40,9 +40,6 @@ export const transformPrismaComponentsHistories = (
         "Call the provided tool function to generate Prisma DB schema",
         "referencing below requirement analysis report.",
         "",
-        "## User Request",
-        state.analyze.reason,
-        "",
         `## Requirement Analysis Report`,
         "",
         "```json",
@@ -69,14 +66,24 @@ export const transformPrismaComponentsHistories = (
         "",
         "* `mv_shopping_daily_stats`",
         "",
-        "## User Role Handling",
-        "",
-        "If the Requirement Analysis Report contains User Role information, **do not normalize** user roles into a single table.",
-        "Instead, create separate tables for each distinct role mentioned in the requirements.",
-        "",
-        "For example, if the requirements mention User, Admin, and Moderator roles:",
         "",
-        "* Create separate tables: `User`, `Admin`, `Moderator` (or with prefix: `shopping_user`, `shopping_admin`, `shopping_moderator`)",
+        state.analyze.roles.length > 0
+          ? [
+              "## User Role Handling",
+              "",
+              `The Requirement Analysis Report contains the following user roles: ${state.analyze.roles.join(", ")}.`,
+              "",
+              "**Do not normalize** user roles into a single table.",
+              "Instead, create separate tables for each distinct role mentioned in the requirements.",
+              "",
+              "Create separate tables for each role:",
+              "",
+              state.analyze.roles
+                .map((role) => `* ${prefix}_${role.name.toLowerCase()}`)
+                .join("\n"),
+              "",
+            ].join("\n")
+          : "",
       ].join("\n"),
     },
   ];

package/src/orchestrate/realize/ProviderCodeComparator.ts

@@ -0,0 +1,15 @@
+import { AutoBeOpenApi } from "@autobe/interface";
+import { hash } from "tstl";
+
+export namespace ProviderCodeComparator {
+  export function hashCode(e: AutoBeOpenApi.IEndpoint): number {
+    return hash(e.path, e.method);
+  }
+
+  export function equals(
+    x: AutoBeOpenApi.IEndpoint,
+    y: AutoBeOpenApi.IEndpoint,
+  ): boolean {
+    return x.path === y.path && x.method === y.method;
+  }
+}