@autobe/agent 0.17.1 → 0.18.0

package/src/context/AutoBeContext.ts

@@ -1,9 +1,14 @@
-import { IAgenticaVendor } from "@agentica/core";
+import {
+  IAgenticaVendor,
+  IMicroAgenticaHistoryJson,
+  MicroAgenticaHistory,
+} from "@agentica/core";
 import {
   AutoBeAnalyzeHistory,
   AutoBeAssistantMessageEvent,
   AutoBeAssistantMessageHistory,
   AutoBeEvent,
+  AutoBeEventSource,
   AutoBeHistory,
   AutoBeInterfaceHistory,
   AutoBePrismaHistory,
@@ -12,29 +17,39 @@ import {
   IAutoBeCompiler,
   IAutoBeCompilerListener,
   IAutoBeGetFilesOptions,
+  IAutoBeTokenUsageJson,
 } from "@autobe/interface";
-import { ILlmSchema } from "@samchon/openapi";
+import { ILlmController, ILlmSchema } from "@samchon/openapi";
 
-import { IAutoBeConfig } from "../structures/IAutoBeConfig";
 import { AutoBeState } from "./AutoBeState";
 import { AutoBeTokenUsage } from "./AutoBeTokenUsage";
 
 export interface AutoBeContext<Model extends ILlmSchema.Model> {
+  // configuration
   model: Model;
   vendor: IAgenticaVendor;
-  config: IAutoBeConfig | undefined;
+  locale: string;
+
+  // accessors
   compilerListener: IAutoBeCompilerListener;
   compiler: () => Promise<IAutoBeCompiler>;
   files: (options: IAutoBeGetFilesOptions) => Promise<Record<string, string>>;
   histories: () => Readonly<AutoBeHistory[]>;
   state: () => Readonly<AutoBeState>;
   usage: () => AutoBeTokenUsage;
+
+  // events
   dispatch: <Event extends Exclude<AutoBeEvent, AutoBeAssistantMessageEvent>>(
     event: Event,
   ) => AutoBeContext.DispatchHistory<Event>;
   assistantMessage: (
     message: AutoBeAssistantMessageHistory,
   ) => AutoBeAssistantMessageHistory;
+
+  // factories
+  conversate(
+    props: AutoBeContext.IConversate<Model>,
+  ): Promise<AutoBeContext.IResult<Model>>;
 }
 export namespace AutoBeContext {
   export type DispatchHistory<
@@ -50,4 +65,15 @@ export namespace AutoBeContext {
     testComplete: AutoBeTestHistory;
     realizeComplete: AutoBeRealizeHistory;
   };
+  export interface IConversate<Model extends ILlmSchema.Model> {
+    source: AutoBeEventSource;
+    controller: ILlmController<Model>;
+    histories: Array<IMicroAgenticaHistoryJson>;
+    enforceFunctionCall: boolean;
+    message: string;
+  }
+  export interface IResult<Model extends ILlmSchema.Model> {
+    histories: MicroAgenticaHistory<Model>[];
+    tokenUsage: IAutoBeTokenUsageJson.IComponent;
+  }
 }

package/src/context/AutoBeTokenUsage.ts

@@ -234,6 +234,14 @@ export class AutoBeTokenUsage implements IAutoBeTokenUsageJson {
     return this;
   }
 
+  /** @internal */
+  public decrement(usage: AutoBeTokenUsage) {
+    AutoBeTokenUsage.keys().forEach((key) => {
+      this[key].decrement(usage[key]);
+    });
+    return this;
+  }
+
   /**
    * Create a new instance combining token usage from two sources.
    *

package/src/context/AutoBeTokenUsageComponent.ts

@@ -114,8 +114,16 @@ export class AutoBeTokenUsageComponent
   public toJSON(): IAutoBeTokenUsageJson.IComponent {
     return {
       total: this.total,
-      input: this.input,
-      output: this.output,
+      input: {
+        total: this.input.total,
+        cached: this.input.cached,
+      },
+      output: {
+        total: this.output.total,
+        reasoning: this.output.reasoning,
+        accepted_prediction: this.output.accepted_prediction,
+        rejected_prediction: this.output.rejected_prediction,
+      },
     };
   }
 
@@ -146,6 +154,16 @@ export class AutoBeTokenUsageComponent
     this.output.rejected_prediction += props.output.rejected_prediction;
   }
 
+  /** @internal */
+  public decrement(props: IAutoBeTokenUsageJson.IComponent) {
+    this.input.total -= props.input.total;
+    this.input.cached -= props.input.cached;
+    this.output.total -= props.output.total;
+    this.output.reasoning -= props.output.reasoning;
+    this.output.accepted_prediction -= props.output.accepted_prediction;
+    this.output.rejected_prediction -= props.output.rejected_prediction;
+  }
+
   /**
    * Create new component combining two token usage statistics.
    *

package/src/factory/createAutoBeApplication.ts

@@ -19,7 +19,7 @@ export const createAutoBeController = <Model extends ILlmSchema.Model>(props: {
   assertSchemaModel(props.model);
   const application: ILlmApplication<Model> = collection[
     props.model
-  ] as unknown as ILlmApplication<Model>;
+  ] satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
   return {
     protocol: "class",
     name: "autobe",
@@ -113,17 +113,9 @@ export const createAutoBeController = <Model extends ILlmSchema.Model>(props: {
   };
 };
 
-const claude = typia.llm.application<
-  IAutoBeApplication,
-  "claude",
-  { reference: true }
->();
+const claude = typia.llm.application<IAutoBeApplication, "claude">();
 const collection = {
-  chatgpt: typia.llm.application<
-    IAutoBeApplication,
-    "chatgpt",
-    { reference: true }
-  >(),
+  chatgpt: typia.llm.application<IAutoBeApplication, "chatgpt">(),
   claude,
   llama: claude,
   deepseek: claude,

package/src/factory/createAutoBeContext.ts

@@ -1,3 +1,4 @@
+import { MicroAgentica, MicroAgenticaHistory } from "@agentica/core";
 import {
   AutoBeAnalyzeCompleteEvent,
   AutoBeAnalyzeHistory,
@@ -20,13 +21,16 @@ import {
   IAutoBeCompiler,
   IAutoBeCompilerListener,
   IAutoBeGetFilesOptions,
+  IAutoBeTokenUsageJson,
 } from "@autobe/interface";
 import { ILlmSchema } from "@samchon/openapi";
+import typia from "typia";
 import { v4 } from "uuid";
 
 import { AutoBeContext } from "../context/AutoBeContext";
 import { AutoBeState } from "../context/AutoBeState";
 import { AutoBeTokenUsage } from "../context/AutoBeTokenUsage";
+import { IAutoBeApplication } from "../context/IAutoBeApplication";
 import { IAutoBeConfig } from "../structures/IAutoBeConfig";
 import { IAutoBeVendor } from "../structures/IAutoBeVendor";
 
@@ -44,7 +48,7 @@ export const createAutoBeContext = <Model extends ILlmSchema.Model>(props: {
 }): AutoBeContext<Model> => ({
   model: props.model,
   vendor: props.vendor,
-  config: props.config,
+  locale: props.config.locale ?? "en-US",
   compilerListener: props.compilerListener,
   compiler: props.compiler,
   files: props.files,
@@ -57,6 +61,49 @@ export const createAutoBeContext = <Model extends ILlmSchema.Model>(props: {
     setTimeout(() => props.dispatch(message).catch(() => {}));
     return message;
   },
+  conversate: async (next) => {
+    const execute = async (): Promise<AutoBeContext.IResult<Model>> => {
+      const agent: MicroAgentica<Model> = new MicroAgentica<Model>({
+        model: props.model,
+        vendor: props.vendor,
+        config: {
+          ...(props.config ?? {}),
+          executor: {
+            describe: null,
+          },
+        },
+        histories: next.histories,
+        controllers: [next.controller],
+      });
+      if (next.enforceFunctionCall === true)
+        agent.on("request", (event) => {
+          if (event.body.tools) event.body.tool_choice = "required";
+          if (event.body.parallel_tool_calls !== undefined)
+            delete event.body.parallel_tool_calls;
+        });
+      const histories: MicroAgenticaHistory<Model>[] = await agent.conversate(
+        next.message,
+      );
+      const tokenUsage: IAutoBeTokenUsageJson.IComponent = agent
+        .getTokenUsage()
+        .toJSON().aggregate;
+      props
+        .usage()
+        .record(tokenUsage, [
+          STAGES.find((stage) => next.source.startsWith(stage)) ?? "analyze",
+        ]);
+      if (
+        next.enforceFunctionCall === true &&
+        histories.every((h) => h.type !== "execute")
+      )
+        throw new Error(
+          `Failed to function calling in the ${next.source} step`,
+        );
+      return { histories, tokenUsage };
+    };
+    if (next.enforceFunctionCall === true) return forceRetry(() => execute());
+    else return execute();
+  },
 });
 
 const createDispatch = (props: {
@@ -191,3 +238,19 @@ const transformAndDispatch = <
   props.dispatch(props.event).catch(() => {});
   return props.history;
 };
+
+const forceRetry = async <T>(
+  task: () => Promise<T>,
+  count: number = 2,
+): Promise<T> => {
+  let error: unknown = undefined;
+  for (let i: number = 0; i <= count; ++i)
+    try {
+      return await task();
+    } catch (e) {
+      error = e;
+    }
+  throw error;
+};
+
+const STAGES = typia.misc.literals<keyof IAutoBeApplication>();

package/src/factory/getAutoBeGenerated.ts

@@ -21,9 +21,9 @@ export async function getAutoBeGenerated(
   Object.assign<Record<string, string>, Record<string, string>>(
     ret,
     Object.fromEntries(
-      Object.entries(state.analyze.files).map(([key, value]) => [
-        `docs/analysis/${key.split("/").at(-1)}`,
-        value,
+      state.analyze.files.map((file) => [
+        `docs/analysis/${file.filename.split("/").at(-1)}`,
+        file.content,
       ]),
     ),
   );

package/src/orchestrate/analyze/histories/transformAnalyzeReviewerHistories.ts

@@ -0,0 +1,53 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import { AutoBeAnalyzeScenarioEvent } from "@autobe/interface";
+import { AutoBeAnalyzeFile } from "@autobe/interface/src/histories/contents/AutoBeAnalyzeFile";
+import { v4 } from "uuid";
+
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+import { transformAnalyzeWriteHistories } from "./transformAnalyzeWriteHistories";
+
+export const transformAnalyzeReviewerHistories = (
+  scenario: AutoBeAnalyzeScenarioEvent,
+  otherFiles: AutoBeAnalyzeFile[],
+  myFile: AutoBeAnalyzeFile,
+): Array<
+  IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
+> => {
+  return [
+    ...transformAnalyzeWriteHistories(scenario, myFile),
+    {
+      id: v4(),
+      created_at: new Date().toISOString(),
+      type: "assistantMessage",
+      text: [
+        "Here are the other documents written in other agents:",
+        "",
+        "```json",
+        JSON.stringify(otherFiles),
+        "```",
+        "",
+        "And here is the target document to review what you have written:",
+        "",
+        "```json",
+        JSON.stringify(myFile),
+        "```",
+      ].join("\n"),
+    },
+    {
+      id: v4(),
+      created_at: new Date().toISOString(),
+      type: "systemMessage",
+      text: AutoBeSystemPromptConstant.ANALYZE_REVIEW,
+    },
+    {
+      id: v4(),
+      created_at: new Date().toISOString(),
+      type: "assistantMessage",
+      text: [
+        `You have to review the ${myFile.filename} document.`,
+        "",
+        "Note that, never review others.",
+      ].join("\n"),
+    },
+  ];
+};

package/src/orchestrate/analyze/histories/transformAnalyzeScenarioHistories.ts

@@ -0,0 +1,34 @@
+import { IMicroAgenticaHistoryJson } from "@agentica/core";
+import { ILlmSchema } from "@samchon/openapi";
+import { v4 } from "uuid";
+
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+import { AutoBeContext } from "../../../context/AutoBeContext";
+
+export function transformAnalyzeSceHistories<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+): Array<IMicroAgenticaHistoryJson> {
+  return [
+    ...ctx
+      .histories()
+      .filter((h) => h.type === "userMessage" || h.type === "assistantMessage"),
+    {
+      id: v4(),
+      type: "systemMessage",
+      text: AutoBeSystemPromptConstant.ANALYZE_SCENARIO,
+      created_at: new Date().toISOString(),
+    },
+    {
+      id: v4(),
+      type: "systemMessage",
+      text: [
+        "One agent per page of the document you specify will write according to the instructions below.",
+        "You should also refer to the content to define the document list.",
+        "```",
+        AutoBeSystemPromptConstant.ANALYZE_WRITE,
+        "```",
+      ].join("\n"),
+      created_at: new Date().toISOString(),
+    },
+  ];
+}

package/src/orchestrate/analyze/histories/transformAnalyzeWriteHistories.ts

@@ -0,0 +1,56 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import { AutoBeAnalyzeScenarioEvent } from "@autobe/interface";
+import { AutoBeAnalyzeFile } from "@autobe/interface/src/histories/contents/AutoBeAnalyzeFile";
+import { v4 } from "uuid";
+
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+
+export const transformAnalyzeWriteHistories = (
+  scenario: AutoBeAnalyzeScenarioEvent,
+  file: AutoBeAnalyzeFile.Scenario,
+): Array<
+  IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
+> => {
+  return [
+    {
+      id: v4(),
+      created_at: new Date().toISOString(),
+      type: "systemMessage",
+      text: AutoBeSystemPromptConstant.ANALYZE_WRITE,
+    },
+    {
+      id: v4(),
+      created_at: new Date().toISOString(),
+      type: "assistantMessage",
+      text: [
+        "## Metadata",
+        "",
+        `Prefix name of the service to create is ${scenario.prefix},`,
+        "and here is the list of the roles you should reference:",
+        "",
+        "```json",
+        JSON.stringify(scenario.roles),
+        "```",
+        "",
+        "Here is the entire list of the documents that would be published",
+        "in someday, and your role is to writing a document of them:",
+        "",
+        "## The other documents that would be published in someday",
+        "```json",
+        JSON.stringify(
+          scenario.files.filter((f) => f.filename !== file.filename),
+        ),
+        "```",
+        "",
+        "## The document what you have to write",
+        "```json",
+        JSON.stringify(file),
+        "```",
+        "",
+        "## Language",
+        "",
+        `The language of the document is ${scenario.language ?? "en-US"}.`,
+      ].join("\n"),
+    },
+  ];
+};

package/src/orchestrate/analyze/orchestrateAnalyze.ts

@@ -1,108 +1,89 @@
 import {
   AutoBeAnalyzeHistory,
+  AutoBeAnalyzeReviewEvent,
+  AutoBeAnalyzeScenarioEvent,
+  AutoBeAnalyzeWriteEvent,
   AutoBeAssistantMessageHistory,
 } from "@autobe/interface";
+import { AutoBeAnalyzeFile } from "@autobe/interface/src/histories/contents/AutoBeAnalyzeFile";
 import { ILlmSchema } from "@samchon/openapi";
-import { IPointer } from "tstl";
-import { v4 } from "uuid";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { IAutoBeApplicationProps } from "../../context/IAutoBeApplicationProps";
-import { orchestrateAnalyzeComposer } from "./orchestrateAnalyzeComposer";
-import { IComposeInput } from "./structures/IAutoBeAnalyzeComposerApplication";
-import { writeDocumentUntilReviewPassed } from "./writeDocumentUntilReviewPassed";
+import { IProgress } from "../internal/IProgress";
+import { orchestrateAnalyzeReview } from "./orchestrateAnalyzeReview";
+import { orchestrateAnalyzeScenario } from "./orchestrateAnalyzeScenario";
+import { orchestrateAnalyzeWrite } from "./orchestrateAnalyzeWrite";
 
-/** @todo Kakasoo */
 export const orchestrateAnalyze =
   <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>) =>
   async (
     props: IAutoBeApplicationProps,
   ): Promise<AutoBeAssistantMessageHistory | AutoBeAnalyzeHistory> => {
-    const step: number = ctx.state().analyze?.step ?? 0;
-    const created_at: string = new Date().toISOString();
+    // Initialize analysis state
+    const step: number = (ctx.state().analyze?.step ?? -1) + 1;
+    const startTime: Date = new Date();
+
     ctx.dispatch({
       type: "analyzeStart",
       reason: props.reason,
       step,
-      created_at,
-    });
-
-    const composeInputPointer: IPointer<IComposeInput | null> = { value: null };
-    const agentica = orchestrateAnalyzeComposer(ctx, (v) => {
-      composeInputPointer.value = v;
+      created_at: startTime.toISOString(),
     });
 
-    const determined = await agentica
-      .conversate(
-        [
-          `Design a complete list of documents and user roles for this project.`,
-          `Define user roles that can authenticate via API and create appropriate documentation files.`,
-          `You must respect the number of documents specified by the user.`,
-        ].join("\n"),
-      )
-      .finally(() => {
-        const tokenUsage = agentica.getTokenUsage().aggregate;
-        ctx.usage().record(tokenUsage, ["analyze"]);
-      });
+    // Generate analysis scenario
+    const scenario: AutoBeAnalyzeScenarioEvent | AutoBeAssistantMessageHistory =
+      await orchestrateAnalyzeScenario(ctx);
+    if (scenario.type === "assistantMessage")
+      return ctx.assistantMessage(scenario);
+    else ctx.dispatch(scenario);
 
-    const composeInput = composeInputPointer.value;
-    if (composeInput === null)
-      return ctx.assistantMessage({
-        id: v4(),
-        text: "Failed to analyze your request. please request again.",
-        type: "assistantMessage",
-        completed_at: new Date().toISOString(),
-        created_at: new Date().toISOString(),
-      });
-
-    const { files: tableOfContents, prefix, roles } = composeInput;
-    if (tableOfContents.length === 0)
-      return ctx.assistantMessage({
-        id: v4(),
-        type: "assistantMessage",
-        text: "The current requirements are insufficient, so file generation will be suspended. It would be better to continue the conversation.",
-        created_at,
-        completed_at: new Date().toISOString(),
-      });
-
-    const retryCount = 3 as const;
-    const progress = {
-      total: tableOfContents.length * retryCount,
+    // write documents
+    const writeProgress: IProgress = {
+      total: scenario.files.length,
       completed: 0,
     };
-    const pointers = await Promise.all(
-      tableOfContents.map(async ({ filename }) => {
-        return await writeDocumentUntilReviewPassed(ctx, {
-          totalFiles: tableOfContents,
-          filename,
-          roles,
-          progress,
-          retry: retryCount,
-        });
+    const fileList: AutoBeAnalyzeFile[] = await Promise.all(
+      scenario.files.map(async (file) => {
+        const event: AutoBeAnalyzeWriteEvent = await orchestrateAnalyzeWrite(
+          ctx,
+          scenario,
+          file,
+          writeProgress,
+        );
+        return event.file;
       }),
     );
 
-    const files = pointers
-      .map((pointer) => {
-        return pointer.value?.files ?? {};
-      })
-      .reduce((acc, cur) => Object.assign(acc, cur));
+    // review documents
+    const reviewProgress: IProgress = {
+      total: fileList.length,
+      completed: 0,
+    };
+    const newFiles: AutoBeAnalyzeFile[] = await Promise.all(
+      fileList.map(async (file, i) => {
+        const event: AutoBeAnalyzeReviewEvent = await orchestrateAnalyzeReview(
+          ctx,
+          scenario,
+          fileList.filter((_, j) => j !== i), // other files
+          file,
+          reviewProgress,
+        );
+        return {
+          ...event.file,
+          content: event.content,
+        };
+      }),
+    );
 
-    if (Object.keys(files).length) {
-      return ctx.dispatch({
-        type: "analyzeComplete",
-        prefix,
-        files,
-        step,
-        roles,
-        created_at,
-      });
-    }
-    return ctx.assistantMessage({
-      id: v4(),
-      type: "assistantMessage",
-      text: determined.find((el) => el.type === "assistantMessage")?.text ?? "",
-      created_at,
-      completed_at: new Date().toISOString(),
-    });
+    // Complete the analysis
+    return ctx.dispatch({
+      type: "analyzeComplete",
+      roles: scenario.roles,
+      prefix: scenario.prefix,
+      files: newFiles,
+      step,
+      elapsed: new Date().getTime() - startTime.getTime(),
+      created_at: new Date().toISOString(),
+    }) satisfies AutoBeAnalyzeHistory;
   };

package/src/orchestrate/analyze/orchestrateAnalyzeReview.ts

@@ -0,0 +1,89 @@
+import { IAgenticaController } from "@agentica/core";
+import {
+  AutoBeAnalyzeReviewEvent,
+  AutoBeAnalyzeScenarioEvent,
+} from "@autobe/interface";
+import { AutoBeAnalyzeFile } from "@autobe/interface/src/histories/contents/AutoBeAnalyzeFile";
+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 { IProgress } from "../internal/IProgress";
+import { transformAnalyzeReviewerHistories } from "./histories/transformAnalyzeReviewerHistories";
+import { IAutoBeAnalyzeReviewApplication } from "./structures/IAutoBeAnalyzeReviewApplication";
+
+export const orchestrateAnalyzeReview = async <Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  scenario: AutoBeAnalyzeScenarioEvent,
+  otherFiles: AutoBeAnalyzeFile[],
+  myFile: AutoBeAnalyzeFile,
+  progress: IProgress,
+): Promise<AutoBeAnalyzeReviewEvent> => {
+  const pointer: IPointer<IAutoBeAnalyzeReviewApplication.IProps | null> = {
+    value: null,
+  };
+  const { tokenUsage } = await ctx.conversate({
+    source: "analyzeReview",
+    controller: createController({
+      model: ctx.model,
+      pointer,
+    }),
+    histories: [
+      ...transformAnalyzeReviewerHistories(scenario, otherFiles, myFile),
+    ],
+    enforceFunctionCall: true,
+    message: "Review the requirement document",
+  });
+  if (pointer.value === null)
+    throw new Error("Failed to extract review information.");
+
+  const event: AutoBeAnalyzeReviewEvent = {
+    type: "analyzeReview",
+    file: myFile,
+    plan: pointer.value.plan,
+    review: pointer.value.review,
+    content: pointer.value.content,
+    tokenUsage,
+    total: progress.total,
+    completed: ++progress.completed,
+    step: (ctx.state().analyze?.step ?? -1) + 1,
+    created_at: new Date().toISOString(),
+  };
+  ctx.dispatch(event);
+  return event;
+};
+
+function createController<Model extends ILlmSchema.Model>(props: {
+  model: Model;
+  pointer: IPointer<IAutoBeAnalyzeReviewApplication.IProps | null>;
+}): IAgenticaController.IClass<Model> {
+  assertSchemaModel(props.model);
+
+  const application: ILlmApplication<Model> = collection[
+    props.model === "chatgpt" ? "chatgpt" : "claude"
+  ] satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
+  return {
+    protocol: "class",
+    name: "Reviewer",
+    application,
+    execute: {
+      review: (input) => {
+        props.pointer.value = input;
+      },
+    } satisfies IAutoBeAnalyzeReviewApplication,
+  };
+}
+
+const claude = typia.llm.application<
+  IAutoBeAnalyzeReviewApplication,
+  "claude"
+>();
+const collection = {
+  chatgpt: typia.llm.application<IAutoBeAnalyzeReviewApplication, "chatgpt">(),
+  claude,
+  llama: claude,
+  deepseek: claude,
+  "3.1": claude,
+};