@autobe/agent 0.16.0 → 0.17.1

package/src/factory/createAutoBeContext.ts

@@ -0,0 +1,193 @@
+import {
+  AutoBeAnalyzeCompleteEvent,
+  AutoBeAnalyzeHistory,
+  AutoBeAnalyzeStartEvent,
+  AutoBeAssistantMessageEvent,
+  AutoBeEvent,
+  AutoBeHistory,
+  AutoBeInterfaceCompleteEvent,
+  AutoBeInterfaceHistory,
+  AutoBeInterfaceStartEvent,
+  AutoBePrismaCompleteEvent,
+  AutoBePrismaHistory,
+  AutoBePrismaStartEvent,
+  AutoBeRealizeCompleteEvent,
+  AutoBeRealizeHistory,
+  AutoBeRealizeStartEvent,
+  AutoBeTestCompleteEvent,
+  AutoBeTestHistory,
+  AutoBeTestStartEvent,
+  IAutoBeCompiler,
+  IAutoBeCompilerListener,
+  IAutoBeGetFilesOptions,
+} from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+import { v4 } from "uuid";
+
+import { AutoBeContext } from "../context/AutoBeContext";
+import { AutoBeState } from "../context/AutoBeState";
+import { AutoBeTokenUsage } from "../context/AutoBeTokenUsage";
+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,
+  config: props.config,
+  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;
+  },
+});
+
+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;
+};

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>> {
@@ -26,6 +27,7 @@ export async function getAutoBeGenerated(
       ]),
     ),
   );
+  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/orchestrateAnalyze.ts

@@ -41,38 +41,29 @@ export const orchestrateAnalyze =
         ].join("\n"),
       )
       .finally(() => {
-        const tokenUsage = agentica.getTokenUsage();
+        const tokenUsage = agentica.getTokenUsage().aggregate;
         ctx.usage().record(tokenUsage, ["analyze"]);
       });
 
     const composeInput = composeInputPointer.value;
-    if (composeInput === null) {
-      return {
+    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) {
-      const history: AutoBeAssistantMessageHistory = {
+    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(),
-      };
-      ctx.dispatch({
-        type: "assistantMessage",
-        text: "The current requirements are insufficient, so file generation will be suspended. It would be better to continue the conversation.",
-        created_at,
       });
-      return history;
-    }
 
     const retryCount = 3 as const;
     const progress = {
@@ -98,40 +89,20 @@ export const orchestrateAnalyze =
       .reduce((acc, cur) => Object.assign(acc, cur));
 
     if (Object.keys(files).length) {
-      const history: AutoBeAnalyzeHistory = {
-        id: v4(),
-        type: "analyze",
-        reason: props.reason,
-        prefix,
-        roles: roles,
-        files: files,
-        step,
-        created_at,
-        completed_at: new Date().toISOString(),
-      };
-      ctx.state().analyze = history;
-      ctx.histories().push(history);
-      ctx.dispatch({
+      return ctx.dispatch({
         type: "analyzeComplete",
         prefix,
         files,
         step,
+        roles,
         created_at,
       });
-      return history;
     }
-
-    const history: AutoBeAssistantMessageHistory = {
+    return ctx.assistantMessage({
       id: v4(),
       type: "assistantMessage",
       text: determined.find((el) => el.type === "assistantMessage")?.text ?? "",
       created_at,
       completed_at: new Date().toISOString(),
-    };
-    ctx.dispatch({
-      type: history.type,
-      text: history.text,
-      created_at: history.created_at,
     });
-    return history;
   };

package/src/orchestrate/analyze/orchestrateAnalyzeReviewer.ts

@@ -55,7 +55,7 @@ export const orchestrateAnalyzeReviewer = async <
 
   const command = `proceed with the review of these files only.` as const;
   await agent.conversate(command).finally(() => {
-    const tokenUsage = agent.getTokenUsage();
+    const tokenUsage = agent.getTokenUsage().aggregate;
     ctx.usage().record(tokenUsage, ["analyze"]);
   });
 

package/src/orchestrate/analyze/writeDocumentUntilReviewPassed.ts

@@ -48,7 +48,7 @@ export async function writeDocumentUntilReviewPassed<
     },
   });
   await writer.conversate("Write Document.").finally(() => {
-    const tokenUsage = writer.getTokenUsage();
+    const tokenUsage = writer.getTokenUsage().aggregate;
     ctx.usage().record(tokenUsage, ["analyze"]);
   });
 

package/src/orchestrate/interface/orchestrateInterface.ts

@@ -6,7 +6,6 @@ import {
   AutoBeOpenApi,
 } from "@autobe/interface";
 import { ILlmSchema } from "@samchon/openapi";
-import { v4 } from "uuid";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { IAutoBeApplicationProps } from "../../context/IAutoBeApplicationProps";
@@ -32,11 +31,8 @@ export const orchestrateInterface =
 
     const init: AutoBeAssistantMessageHistory | AutoBeInterfaceGroupsEvent =
       await orchestrateInterfaceGroups(ctx);
-    if (init.type === "assistantMessage") {
-      ctx.dispatch(init);
-      ctx.histories().push(init);
-      return init;
-    } else ctx.dispatch(init);
+    if (init.type === "assistantMessage") return ctx.assistantMessage(init);
+    else ctx.dispatch(init);
 
     // ENDPOINTS & OPERATIONS
     const endpoints: AutoBeOpenApi.IEndpoint[] =
@@ -58,23 +54,10 @@ export const orchestrateInterface =
     );
 
     // DO COMPILE
-    const result: AutoBeInterfaceHistory = {
-      type: "interface",
-      id: v4(),
-      document,
-      reason: props.reason,
-      step: ctx.state().analyze?.step ?? 0,
-      created_at: start.toISOString(),
-      completed_at: new Date().toISOString(),
-    };
-    ctx.state().interface = result;
-    ctx.histories().push(result);
-    ctx.dispatch({
+    return ctx.dispatch({
       type: "interfaceComplete",
-      document: result.document,
+      document,
       created_at: start.toISOString(),
-      reason: props.reason,
       step: ctx.state().analyze?.step ?? 0,
     } satisfies AutoBeInterfaceCompleteEvent);
-    return result;
   };

package/src/orchestrate/interface/orchestrateInterfaceComplement.ts

@@ -75,7 +75,7 @@ async function step<Model extends ILlmSchema.Model>(
   enforceToolCall(agentica);
 
   await agentica.conversate("Fill missing schema types please").finally(() => {
-    const tokenUsage = agentica.getTokenUsage();
+    const tokenUsage = agentica.getTokenUsage().aggregate;
     ctx.usage().record(tokenUsage, ["interface"]);
   });
   if (pointer.value === null) {

package/src/orchestrate/interface/orchestrateInterfaceEndpoints.ts

@@ -69,7 +69,7 @@ async function process<Model extends ILlmSchema.Model>(
   enforceToolCall(agentica);
 
   await agentica.conversate(content).finally(() => {
-    const tokenUsage = agentica.getTokenUsage();
+    const tokenUsage = agentica.getTokenUsage().aggregate;
     ctx.usage().record(tokenUsage, ["interface"]);
   });
   if (pointer.value === null) throw new Error("Failed to generate endpoints."); // unreachable

package/src/orchestrate/interface/orchestrateInterfaceGroups.ts

@@ -50,7 +50,7 @@ export async function orchestrateInterfaceGroups<
   const histories: MicroAgenticaHistory<Model>[] = await agentica
     .conversate(content)
     .finally(() => {
-      const tokenUsage = agentica.getTokenUsage();
+      const tokenUsage = agentica.getTokenUsage().aggregate;
       ctx.usage().record(tokenUsage, ["interface"]);
     });
   const last: MicroAgenticaHistory<Model> = histories.at(-1)!;

package/src/orchestrate/interface/orchestrateInterfaceOperations.ts

@@ -140,7 +140,7 @@ async function process<Model extends ILlmSchema.Model>(
   });
   enforceToolCall(agentica);
   await agentica.conversate("Make API operations").finally(() => {
-    const tokenUsage = agentica.getTokenUsage();
+    const tokenUsage = agentica.getTokenUsage().aggregate;
     ctx.usage().record(tokenUsage, ["interface"]);
   });
   if (pointer.value === null) throw new Error("Failed to create operations."); // never be happened

package/src/orchestrate/interface/orchestrateInterfaceSchemas.ts

@@ -136,7 +136,7 @@ async function process<Model extends ILlmSchema.Model>(
       ].join("\n"),
     )
     .finally(() => {
-      const tokenUsage = agentica.getTokenUsage();
+      const tokenUsage = agentica.getTokenUsage().aggregate;
       ctx.usage().record(tokenUsage, ["interface"]);
     });
   if (pointer.value === null) {

package/src/orchestrate/prisma/{transformPrismaComponentsHistories.ts → histories/transformPrismaComponentsHistories.ts}

@@ -1,8 +1,8 @@
 import { IAgenticaHistoryJson } from "@agentica/core";
 import { v4 } from "uuid";
 
-import { AutoBeSystemPromptConstant } from "../../constants/AutoBeSystemPromptConstant";
-import { AutoBeState } from "../../context/AutoBeState";
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+import { AutoBeState } from "../../../context/AutoBeState";
 
 export const transformPrismaComponentsHistories = (
   state: AutoBeState,

package/src/orchestrate/prisma/{transformPrismaCorrectHistories.ts → histories/transformPrismaCorrectHistories.ts}

@@ -2,7 +2,7 @@ import { IAgenticaHistoryJson } from "@agentica/core";
 import { IAutoBePrismaValidation } from "@autobe/interface";
 import { v4 } from "uuid";
 
-import { AutoBeSystemPromptConstant } from "../../constants/AutoBeSystemPromptConstant";
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
 
 export const transformPrismaCorrectHistories = (
   result: IAutoBePrismaValidation.IFailure,

package/src/orchestrate/prisma/{transformPrismaHistories.ts → histories/transformPrismaHistories.ts}

@@ -1,8 +1,8 @@
 import { IAgenticaHistoryJson } from "@agentica/core";
 import { v4 } from "uuid";
 
-import { AutoBeSystemPromptConstant } from "../../constants/AutoBeSystemPromptConstant";
-import { AutoBeState } from "../../context/AutoBeState";
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+import { AutoBeState } from "../../../context/AutoBeState";
 
 export const transformPrismaHistories = (
   state: AutoBeState,

package/src/orchestrate/prisma/{transformPrismaSchemaHistories.ts → histories/transformPrismaSchemaHistories.ts}

@@ -2,7 +2,7 @@ import { IAgenticaHistoryJson } from "@agentica/core";
 import { AutoBePrisma } from "@autobe/interface";
 import { v4 } from "uuid";
 
-import { AutoBeSystemPromptConstant } from "../../constants/AutoBeSystemPromptConstant";
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
 
 export const transformPrismaSchemaHistories = (
   requirementAnalysisReport: Record<string, string>,