@autobe/agent 0.16.1 → 0.18.0

package/src/factory/createAutoBeContext.ts

@@ -0,0 +1,256 @@
+import { MicroAgentica, MicroAgenticaHistory } from "@agentica/core";
+import {
+  AutoBeAnalyzeCompleteEvent,
+  AutoBeAnalyzeHistory,
+  AutoBeAnalyzeStartEvent,
+  AutoBeAssistantMessageEvent,
+  AutoBeEvent,
+  AutoBeHistory,
+  AutoBeInterfaceCompleteEvent,
+  AutoBeInterfaceHistory,
+  AutoBeInterfaceStartEvent,
+  AutoBePrismaCompleteEvent,
+  AutoBePrismaHistory,
+  AutoBePrismaStartEvent,
+  AutoBeRealizeCompleteEvent,
+  AutoBeRealizeHistory,
+  AutoBeRealizeStartEvent,
+  AutoBeTestCompleteEvent,
+  AutoBeTestHistory,
+  AutoBeTestStartEvent,
+  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";
+
+export const createAutoBeContext = <Model extends ILlmSchema.Model>(props: {
+  model: Model;
+  vendor: IAutoBeVendor;
+  compiler: () => Promise<IAutoBeCompiler>;
+  compilerListener: IAutoBeCompilerListener;
+  config: IAutoBeConfig;
+  state: () => AutoBeState;
+  files: (options: IAutoBeGetFilesOptions) => Promise<Record<string, string>>;
+  histories: () => AutoBeHistory[];
+  usage: () => AutoBeTokenUsage;
+  dispatch: (event: AutoBeEvent) => Promise<void>;
+}): AutoBeContext<Model> => ({
+  model: props.model,
+  vendor: props.vendor,
+  locale: props.config.locale ?? "en-US",
+  compilerListener: props.compilerListener,
+  compiler: props.compiler,
+  files: props.files,
+  histories: props.histories,
+  state: props.state,
+  usage: props.usage,
+  dispatch: createDispatch(props),
+  assistantMessage: (message) => {
+    props.histories().push(message);
+    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: {
+  state: () => AutoBeState;
+  histories: () => AutoBeHistory[];
+  dispatch: (event: AutoBeEvent) => Promise<void>;
+}) => {
+  let analyzeStart: AutoBeAnalyzeStartEvent | null = null;
+  let prismaStart: AutoBePrismaStartEvent | null = null;
+  let interfaceStart: AutoBeInterfaceStartEvent | null = null;
+  let testStart: AutoBeTestStartEvent | null = null;
+  let realizeStart: AutoBeRealizeStartEvent | null = null;
+  return <Event extends Exclude<AutoBeEvent, AutoBeAssistantMessageEvent>>(
+    event: Event,
+  ): AutoBeContext.DispatchHistory<Event> => {
+    // starts
+    if (event.type === "analyzeStart") analyzeStart = event;
+    else if (event.type === "prismaStart") prismaStart = event;
+    else if (event.type === "interfaceStart") interfaceStart = event;
+    else if (event.type === "testStart") testStart = event;
+    else if (event.type === "realizeStart") realizeStart = event;
+    // completes
+    else if (event.type === "analyzeComplete")
+      return transformAndDispatch<AutoBeAnalyzeCompleteEvent>({
+        dispatch: props.dispatch,
+        histories: props.histories,
+        state: props.state,
+        event,
+        history: {
+          type: "analyze",
+          id: v4(),
+          reason: analyzeStart?.reason ?? "",
+          prefix: event.prefix,
+          roles: event.roles,
+          files: event.files,
+          created_at: analyzeStart?.created_at ?? new Date().toISOString(),
+          completed_at: event.created_at,
+          step: event.step,
+        } satisfies AutoBeAnalyzeHistory,
+      }) as AutoBeContext.DispatchHistory<Event>;
+    else if (event.type === "prismaComplete")
+      return transformAndDispatch<AutoBePrismaCompleteEvent>({
+        dispatch: props.dispatch,
+        histories: props.histories,
+        state: props.state,
+        event,
+        history: {
+          type: "prisma",
+          id: v4(),
+          reason: prismaStart?.reason ?? "",
+          schemas: event.schemas,
+          result: event.result,
+          compiled: event.compiled,
+          created_at: prismaStart?.created_at ?? new Date().toISOString(),
+          completed_at: event.created_at,
+          step: event.step,
+        } satisfies AutoBePrismaHistory,
+      }) as AutoBeContext.DispatchHistory<Event>;
+    else if (event.type === "interfaceComplete")
+      return transformAndDispatch({
+        dispatch: props.dispatch,
+        histories: props.histories,
+        state: props.state,
+        event,
+        history: {
+          type: "interface",
+          id: v4(),
+          reason: interfaceStart?.reason ?? "",
+          document: event.document,
+          created_at: interfaceStart?.created_at ?? new Date().toISOString(),
+          completed_at: new Date().toISOString(),
+          step: event.step,
+        } satisfies AutoBeInterfaceHistory,
+      }) as AutoBeContext.DispatchHistory<Event>;
+    else if (event.type === "testComplete")
+      return transformAndDispatch<AutoBeTestCompleteEvent>({
+        dispatch: props.dispatch,
+        histories: props.histories,
+        state: props.state,
+        event,
+        history: {
+          type: "test",
+          id: v4(),
+          reason: testStart?.reason ?? "",
+          files: event.files,
+          compiled: event.compiled,
+          created_at: testStart?.created_at ?? new Date().toISOString(),
+          completed_at: new Date().toISOString(),
+          step: event.step,
+        } satisfies AutoBeTestHistory,
+      }) as AutoBeContext.DispatchHistory<Event>;
+    else if (event.type === "realizeComplete")
+      return transformAndDispatch<AutoBeRealizeCompleteEvent>({
+        dispatch: props.dispatch,
+        histories: props.histories,
+        state: props.state,
+        event,
+        history: {
+          type: "realize",
+          id: v4(),
+          reason: realizeStart?.reason ?? "",
+          authorizations: event.authorizations,
+          functions: event.functions,
+          controllers: event.controllers,
+          compiled: event.compiled,
+          created_at: realizeStart?.created_at ?? new Date().toISOString(),
+          completed_at: new Date().toISOString(),
+          step: event.step,
+        } satisfies AutoBeRealizeHistory,
+      }) as AutoBeContext.DispatchHistory<Event>;
+    props.dispatch(event).catch(() => {});
+    return null as AutoBeContext.DispatchHistory<Event>;
+  };
+};
+
+const transformAndDispatch = <
+  Event extends
+    | AutoBeAnalyzeCompleteEvent
+    | AutoBePrismaCompleteEvent
+    | AutoBeInterfaceCompleteEvent
+    | AutoBeTestCompleteEvent
+    | AutoBeRealizeCompleteEvent,
+>(props: {
+  dispatch: (event: Event) => Promise<void>;
+  histories: () => AutoBeHistory[];
+  state: () => AutoBeState;
+  event: Event;
+  history: NonNullable<AutoBeContext.DispatchHistory<Event>>;
+}): NonNullable<AutoBeContext.DispatchHistory<Event>> => {
+  props.histories().push(props.history);
+  props.state()[props.history.type] = props.history as any;
+  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

@@ -6,11 +6,12 @@ import {
 
 import { AutoBeState } from "../context/AutoBeState";
 import { AutoBeTokenUsage } from "../context/AutoBeTokenUsage";
+import { getAutoBeRealizeGenerated } from "./getAutoBeRealizeGenerated";
 
 export async function getAutoBeGenerated(
   compiler: IAutoBeCompiler,
   state: AutoBeState,
-  histories: AutoBeHistory[],
+  histories: Readonly<AutoBeHistory[]>,
   tokenUsage: AutoBeTokenUsage,
   options?: Partial<IAutoBeGetFilesOptions>,
 ): Promise<Record<string, string>> {
@@ -20,12 +21,13 @@ 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,
       ]),
     ),
   );
+  if (options?.stage === "analyze") return ret;
 
   // PRISMA
   if (state.prisma?.step === state.analyze.step) {
@@ -54,6 +56,7 @@ export async function getAutoBeGenerated(
     else if (state.prisma.compiled.type === "failure")
       ret["prisma/compile-error-reason.log"] = state.prisma.compiled.reason;
   }
+  if (options?.stage === "prisma") return ret;
 
   // INTERFACE
   if (state.interface?.step === state.analyze.step) {
@@ -78,6 +81,7 @@ export async function getAutoBeGenerated(
       },
     );
   }
+  if (options?.stage === "interface") return ret;
 
   // TEST
   if (state.test?.step === state.analyze.step)
@@ -92,28 +96,17 @@ export async function getAutoBeGenerated(
     );
 
   // REALIZE
-  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]),
-      ),
-      ...Object.fromEntries(
-        state.realize.authorizations
-          .map((auth) => [
-            [auth.decorator.location, auth.decorator.content],
-            [auth.provider.location, auth.provider.content],
-            [auth.payload.location, auth.payload.content],
-          ])
-          .flat(),
-      ),
-      ...(await compiler.realize.getTemplate()),
-      ...(await compiler.realize.controller({
+  if (state.realize?.step === state.analyze.step)
+    Object.assign<Record<string, string>, Record<string, string>>(
+      ret,
+      await getAutoBeRealizeGenerated({
+        compiler,
         document: state.interface!.document,
-        functions: state.realize.functions,
         authorizations: state.realize.authorizations,
-      })),
-    });
-  }
+        functions: state.realize.functions,
+      }),
+    );
+  if (options?.stage === "test") return ret;
 
   // LOGGING
   Object.assign<Record<string, string>, Record<string, string>>(ret, {

package/src/factory/getAutoBeRealizeGenerated.ts

@@ -0,0 +1,30 @@
+import {
+  AutoBeOpenApi,
+  AutoBeRealizeAuthorization,
+  AutoBeRealizeFunction,
+  IAutoBeCompiler,
+} from "@autobe/interface";
+
+export const getAutoBeRealizeGenerated = async (props: {
+  compiler: IAutoBeCompiler;
+  document: AutoBeOpenApi.IDocument;
+  authorizations: AutoBeRealizeAuthorization[];
+  functions: AutoBeRealizeFunction[];
+}): Promise<Record<string, string>> => ({
+  ...Object.fromEntries(props.functions.map((f) => [f.location, f.content])),
+  ...Object.fromEntries(
+    props.authorizations
+      .map((auth) => [
+        [auth.decorator.location, auth.decorator.content],
+        [auth.provider.location, auth.provider.content],
+        [auth.payload.location, auth.payload.content],
+      ])
+      .flat(),
+  ),
+  ...(await props.compiler.realize.getTemplate()),
+  ...(await props.compiler.realize.controller({
+    document: props.document,
+    functions: props.functions,
+    authorizations: props.authorizations,
+  })),
+});

package/src/index.ts

@@ -1,5 +1,6 @@
 export * from "./AutoBeAgent";
 export * from "./context/AutoBeTokenUsage";
+export * from "./context/AutoBeTokenUsageComponent";
 
 export * from "./structures/IAutoBeProps";
 export * from "./structures/IAutoBeConfig";

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"),
+    },
+  ];
+};