@autobe/agent 0.17.1 → 0.19.1

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.
    *
@@ -177,4 +195,24 @@ export class AutoBeTokenUsageComponent
       },
     });
   }
+
+  public static minus(
+    a: AutoBeTokenUsageComponent,
+    b: AutoBeTokenUsageComponent,
+  ) {
+    return new AutoBeTokenUsageComponent({
+      input: {
+        total: a.input.total - b.input.total,
+        cached: a.input.cached - b.input.cached,
+      },
+      output: {
+        total: a.output.total - b.output.total,
+        reasoning: a.output.reasoning - b.output.reasoning,
+        accepted_prediction:
+          a.output.accepted_prediction - b.output.accepted_prediction,
+        rejected_prediction:
+          a.output.rejected_prediction - b.output.rejected_prediction,
+      },
+    });
+  }
 }

package/src/factory/consentFunctionCall.ts

@@ -0,0 +1,128 @@
+import {
+  IAgenticaHistoryJson,
+  MicroAgentica,
+  MicroAgenticaHistory,
+} from "@agentica/core";
+import {
+  AutoBeConsentFunctionCallEvent,
+  AutoBeEvent,
+  AutoBeEventSource,
+} from "@autobe/interface";
+import { IPointer } from "tstl";
+import typia from "typia";
+import { v4 } from "uuid";
+
+import { AutoBeSystemPromptConstant } from "../constants/AutoBeSystemPromptConstant";
+import { IAutoBeConfig } from "../structures/IAutoBeConfig";
+import { IAutoBeVendor } from "../structures/IAutoBeVendor";
+
+export const consentFunctionCall = async (props: {
+  dispatch: (event: AutoBeEvent) => void;
+  source: AutoBeEventSource;
+  config: IAutoBeConfig;
+  vendor: IAutoBeVendor;
+  assistantMessage: string;
+}): Promise<string | null> => {
+  const pointer: IPointer<AutoBeConsentFunctionCallEvent.IResult | null> = {
+    value: null,
+  };
+  const agent: MicroAgentica<"chatgpt"> = new MicroAgentica({
+    model: "chatgpt",
+    vendor: props.vendor,
+    config: {
+      ...(props.config ?? []),
+      executor: {
+        describe: null,
+      },
+    },
+    histories: [
+      {
+        id: v4(),
+        type: "systemMessage",
+        text: AutoBeSystemPromptConstant.CONSENT_FUNCTION_CALL,
+        created_at: new Date().toISOString(),
+      } satisfies IAgenticaHistoryJson.ISystemMessage,
+      {
+        id: v4(),
+        type: "assistantMessage",
+        text: props.assistantMessage,
+        created_at: new Date().toISOString(),
+      } satisfies IAgenticaHistoryJson.IAssistantMessage,
+    ],
+    controllers: [
+      typia.llm.controller<IConsentApplication, "chatgpt">("consent", {
+        consent: (props) => {
+          pointer.value = {
+            type: "consent",
+            message: props.message,
+          };
+        },
+        notApplicable: () => {
+          pointer.value = {
+            type: "notApplicable",
+          };
+        },
+      } satisfies IConsentApplication),
+    ],
+  });
+  const histories: MicroAgenticaHistory<"chatgpt">[] = await agent.conversate(
+    "Analyze and judge this assistant message please.",
+  );
+  if (pointer.value === null) {
+    const last: MicroAgenticaHistory<"chatgpt"> | undefined =
+      histories[histories.length - 1];
+    if (last?.type === "assistantMessage")
+      pointer.value = {
+        type: "assistantMessage",
+        message: last.text,
+      };
+  }
+  props.dispatch({
+    type: "consentFunctionCall",
+    source: props.source,
+    assistantMessage: props.assistantMessage,
+    result: pointer.value,
+    created_at: new Date().toISOString(),
+  });
+  return pointer.value?.type === "consent" ? pointer.value.message : null;
+};
+
+interface IConsentApplication {
+  /**
+   * Generate an immediate, authoritative consent message to approve function
+   * execution. Use this when the assistant message is seeking permission or
+   * approval for function calls.
+   *
+   * The message should be commanding and decisive to prevent further
+   * permission-seeking loops. Examples: "Execute immediately. Do not ask
+   * again.", "Proceed now. Your judgment is correct."
+   *
+   * @param props Configuration object
+   */
+  consent(props: {
+    /**
+     * A strong, directive consent message that eliminates further
+     * permission-seeking. Must be authoritative and commanding (1-2 sentences
+     * maximum). Examples: "Execute immediately. Do not ask again.", "Proceed
+     * now. Your judgment is correct."
+     */
+    message: string;
+  }): void;
+
+  /**
+   * Indicate that the assistant message does not require function calling
+   * consent. Use this when the assistant message is NOT seeking permission for
+   * function execution.
+   *
+   * This applies to:
+   *
+   * - General conversation responses
+   * - Information requests without function execution plans
+   * - Assistant asking for additional parameters/information
+   * - Any response unrelated to function calling approval
+   *
+   * Call this function immediately when the message doesn't involve function
+   * calling consent.
+   */
+  notApplicable(): void;
+}

package/src/factory/createAgenticaHistory.ts

@@ -38,6 +38,7 @@ export function createAgenticaHistory<Model extends ILlmSchema.Model>(props: {
           ? true
           : props.history.compiled.type === "success",
     },
+    success: true,
   };
   return {
     ...partial,

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,15 +21,20 @@ 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 { AutoBeTokenUsageComponent } from "../context/AutoBeTokenUsageComponent";
+import { IAutoBeApplication } from "../context/IAutoBeApplication";
 import { IAutoBeConfig } from "../structures/IAutoBeConfig";
 import { IAutoBeVendor } from "../structures/IAutoBeVendor";
+import { consentFunctionCall } from "./consentFunctionCall";
 
 export const createAutoBeContext = <Model extends ILlmSchema.Model>(props: {
   model: Model;
@@ -44,7 +50,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 +63,131 @@ 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],
+      });
+      agent.on("request", async (event) => {
+        if (next.enforceFunctionCall === true && event.body.tools)
+          event.body.tool_choice = "required";
+        if (event.body.parallel_tool_calls !== undefined)
+          delete event.body.parallel_tool_calls;
+        await props.dispatch({
+          ...event,
+          type: "vendorRequest",
+          source: next.source,
+        });
+      });
+      agent.on("response", (event) => {
+        void props
+          .dispatch({
+            ...event,
+            type: "vendorResponse",
+            source: next.source,
+          })
+          .catch(() => {});
+      });
+      agent.on("jsonParseError", (event) => {
+        void props
+          .dispatch({
+            ...event,
+            source: next.source,
+          })
+          .catch(() => {});
+      });
+      agent.on("validate", (event) => {
+        void props
+          .dispatch({
+            type: "jsonValidateError",
+            source: next.source,
+            result: event.result,
+            created_at: event.created_at,
+          })
+          .catch(() => {});
+      });
+
+      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 (
+        true === next.enforceFunctionCall &&
+        false ===
+          histories.some((h) => h.type === "execute" && h.success === true)
+      ) {
+        const failure = () => {
+          throw new Error(
+            `Failed to function calling in the ${next.source} step`,
+          );
+        };
+        const last: MicroAgenticaHistory<Model> | undefined = histories.at(-1);
+        if (
+          last?.type === "assistantMessage" &&
+          last.text.trim().length !== 0
+        ) {
+          const consent: string | null = await consentFunctionCall({
+            source: next.source,
+            dispatch: (e) => {
+              props.dispatch(e).catch(() => {});
+            },
+            config: props.config,
+            vendor: props.vendor,
+            assistantMessage: last.text,
+          });
+          if (consent !== null) {
+            const newHistories: MicroAgenticaHistory<Model>[] =
+              await agent.conversate(consent);
+            const newTokenUsage: IAutoBeTokenUsageJson.IComponent = agent
+              .getTokenUsage()
+              .toJSON().aggregate;
+            props
+              .usage()
+              .record(
+                AutoBeTokenUsageComponent.minus(
+                  new AutoBeTokenUsageComponent(newTokenUsage),
+                  new AutoBeTokenUsageComponent(tokenUsage),
+                ),
+                [
+                  STAGES.find((stage) => next.source.startsWith(stage)) ??
+                    "analyze",
+                ],
+              );
+            if (
+              newHistories.some(
+                (h) => h.type === "execute" && h.success === true,
+              )
+            )
+              return {
+                histories: newHistories,
+                tokenUsage: newTokenUsage,
+              };
+          }
+        }
+        failure();
+      }
+      return { histories, tokenUsage };
+    };
+    if (next.enforceFunctionCall === true) return forceRetry(execute);
+    else return execute();
+  },
 });
 
 const createDispatch = (props: {
@@ -125,6 +256,7 @@ const createDispatch = (props: {
           type: "interface",
           id: v4(),
           reason: interfaceStart?.reason ?? "",
+          authorizations: event.authorizations,
           document: event.document,
           created_at: interfaceStart?.created_at ?? new Date().toISOString(),
           completed_at: new Date().toISOString(),
@@ -191,3 +323,19 @@ const transformAndDispatch = <
   props.dispatch(props.event).catch(() => {});
   return props.history;
 };
+
+const forceRetry = async <T>(
+  task: () => Promise<T>,
+  count: number = 3,
+): 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,60 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import { AutoBeAnalyzeScenarioEvent } from "@autobe/interface";
+import { AutoBeAnalyzeFile } from "@autobe/interface/src/histories/contents/AutoBeAnalyzeFile";
+import { ILlmSchema } from "@samchon/openapi";
+import { v4 } from "uuid";
+
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+import { AutoBeContext } from "../../../context/AutoBeContext";
+import { transformAnalyzeWriteHistories } from "./transformAnalyzeWriteHistories";
+
+export const transformAnalyzeReviewerHistories = <
+  Model extends ILlmSchema.Model,
+>(
+  ctx: AutoBeContext<Model>,
+  scenario: AutoBeAnalyzeScenarioEvent,
+  otherFiles: AutoBeAnalyzeFile[],
+  myFile: AutoBeAnalyzeFile,
+): Array<
+  | IAgenticaHistoryJson.IUserMessage
+  | IAgenticaHistoryJson.IAssistantMessage
+  | IAgenticaHistoryJson.ISystemMessage
+> => {
+  return [
+    ...transformAnalyzeWriteHistories(ctx, 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: [
+        `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,78 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import { AutoBeAnalyzeScenarioEvent } from "@autobe/interface";
+import { AutoBeAnalyzeFile } from "@autobe/interface/src/histories/contents/AutoBeAnalyzeFile";
+import { ILlmSchema } from "@samchon/openapi";
+import { v4 } from "uuid";
+
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+import { AutoBeContext } from "../../../context/AutoBeContext";
+
+export const transformAnalyzeWriteHistories = <Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  scenario: AutoBeAnalyzeScenarioEvent,
+  file: AutoBeAnalyzeFile.Scenario,
+): Array<
+  | IAgenticaHistoryJson.IUserMessage
+  | IAgenticaHistoryJson.IAssistantMessage
+  | IAgenticaHistoryJson.ISystemMessage
+> => {
+  return [
+    ...ctx
+      .histories()
+      .filter((h) => h.type === "userMessage" || h.type === "assistantMessage")
+      .map((h) => {
+        const text =
+          h.type === "userMessage"
+            ? h.contents
+                .filter((el) => el.type === "text")
+                .map((el) => el.text)
+                .join("\n")
+            : h.text;
+
+        return {
+          ...h,
+          text,
+        };
+      }),
+    {
+      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 to 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 to write",
+        "```json",
+        JSON.stringify(file),
+        "```",
+        "",
+        "## Language",
+        "",
+        `The language of the document is ${scenario.language ?? "en-US"}.`,
+      ].join("\n"),
+    },
+  ];
+};