@autobe/agent 0.28.1 → 0.29.1

package/src/context/AutoBeContext.ts

@@ -80,7 +80,7 @@ export namespace AutoBeContext {
     controller: ILlmController<Model>;
     histories: Array<IMicroAgenticaHistoryJson>;
     enforceFunctionCall: boolean;
-    message: string;
+    userMessage: string;
     promptCacheKey?: string;
   }
   export interface IResult<Model extends ILlmSchema.Model> {

package/src/factory/createAutoBeContext.ts

@@ -26,7 +26,11 @@ import {
   IAutoBeGetFilesOptions,
   IAutoBeTokenUsageJson,
 } from "@autobe/interface";
-import { StringUtil } from "@autobe/utils";
+import {
+  AutoBeProcessAggregateFactory,
+  StringUtil,
+  TokenUsageComputer,
+} from "@autobe/utils";
 import { ILlmSchema } from "@samchon/openapi";
 import { Semaphore } from "tstl";
 import typia from "typia";
@@ -42,8 +46,6 @@ import { IAutoBeConfig } from "../structures/IAutoBeConfig";
 import { IAutoBeVendor } from "../structures/IAutoBeVendor";
 import { AutoBeTimeoutError } from "../utils/AutoBeTimeoutError";
 import { TimedConversation } from "../utils/TimedConversation";
-import { TokenUsageComputer } from "../utils/TokenUsageComputer";
-import { AutoBeProcessAggregateFactory } from "./AutoBeProcessAggregateFactory";
 import { consentFunctionCall } from "./consentFunctionCall";
 import { getCommonPrompt } from "./getCommonPrompt";
 import { getCriticalCompiler } from "./getCriticalCompiler";
@@ -181,6 +183,7 @@ export const createAutoBeContext = <Model extends ILlmSchema.Model>(props: {
           void props
             .dispatch({
               ...event,
+              function: event.operation.function.name,
               source: next.source,
             })
             .catch(() => {});
@@ -192,6 +195,7 @@ export const createAutoBeContext = <Model extends ILlmSchema.Model>(props: {
               type: "jsonValidateError",
               id: v7(),
               source: next.source,
+              function: event.operation.function.name,
               result: event.result,
               life: event.life,
               created_at: event.created_at,
@@ -204,7 +208,7 @@ export const createAutoBeContext = <Model extends ILlmSchema.Model>(props: {
         const message: string =
           next.enforceFunctionCall === true
             ? StringUtil.trim`
-                ${next.message}
+                ${next.userMessage}
 
                 > You have to call function(s) of below to accomplish my request.
                 >
@@ -220,7 +224,7 @@ export const createAutoBeContext = <Model extends ILlmSchema.Model>(props: {
                   .map((f) => `> - ${f.name}`)
                   .join("\n")}
               `
-            : next.message;
+            : next.userMessage;
         const result: TimedConversation.IResult<Model> =
           await TimedConversation.process({
             timeout: config.timeout,
@@ -243,6 +247,7 @@ export const createAutoBeContext = <Model extends ILlmSchema.Model>(props: {
             histories,
             tokenUsage: aggregate.tokenUsage,
             metric: aggregate.metric,
+            __agent: agent,
           };
         };
         if (result.type === "error") throw result.error;

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

@@ -1,4 +1,3 @@
-import { IAgenticaHistoryJson } from "@agentica/core";
 import { AutoBeAnalyzeScenarioEvent } from "@autobe/interface";
 import { AutoBeAnalyzeFile } from "@autobe/interface/src/histories/contents/AutoBeAnalyzeFile";
 import { StringUtil } from "@autobe/utils";
@@ -7,50 +6,40 @@ import { v7 } from "uuid";
 
 import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
 import { AutoBeContext } from "../../../context/AutoBeContext";
+import { IAutoBeOrchestrateHistory } from "../../../structures/IAutoBeOrchestrateHistory";
+import { AutoBePreliminaryController } from "../../common/AutoBePreliminaryController";
 import { transformAnalyzeWriteHistories } from "./transformAnalyzeWriteHistories";
 
 export const transformAnalyzeReviewHistories = <Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
-  scenario: AutoBeAnalyzeScenarioEvent,
-  allFiles: AutoBeAnalyzeFile[],
-  myFile: AutoBeAnalyzeFile,
-): Array<
-  | IAgenticaHistoryJson.IUserMessage
-  | IAgenticaHistoryJson.IAssistantMessage
-  | IAgenticaHistoryJson.ISystemMessage
-> => {
-  return [
+  props: {
+    scenario: AutoBeAnalyzeScenarioEvent;
+    myFile: AutoBeAnalyzeFile;
+    preliminary: AutoBePreliminaryController<"analysisFiles">;
+  },
+): IAutoBeOrchestrateHistory => ({
+  histories: [
     ...transformAnalyzeWriteHistories(ctx, {
-      scenario,
-      file: myFile,
-    }).slice(0, -2),
+      scenario: props.scenario,
+      file: props.myFile,
+    }).histories.slice(0, -2),
     {
       id: v7(),
       created_at: new Date().toISOString(),
       type: "systemMessage",
       text: AutoBeSystemPromptConstant.ANALYZE_REVIEW,
     },
+    ...props.preliminary.getHistories(),
     {
       id: v7(),
       created_at: new Date().toISOString(),
       type: "assistantMessage",
       text: StringUtil.trim`
-        Here are the all documents written:
-        
-        \`\`\`json
-        ${JSON.stringify(allFiles)}
-        \`\`\`
-      `,
-    },
-    {
-      id: v7(),
-      created_at: new Date().toISOString(),
-      type: "assistantMessage",
-      text: StringUtil.trim`
-        Review the ${myFile.filename} document.
+        Review the ${props.myFile.filename} document.
         
         Note that, never review others.
       `,
     },
-  ];
-};
+  ],
+  userMessage: "Review the requirement document",
+});

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

@@ -1,15 +1,15 @@
-import { IMicroAgenticaHistoryJson } from "@agentica/core";
 import { StringUtil } from "@autobe/utils";
 import { ILlmSchema } from "@samchon/openapi";
 import { v7 } from "uuid";
 
 import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
 import { AutoBeContext } from "../../../context/AutoBeContext";
+import { IAutoBeOrchestrateHistory } from "../../../structures/IAutoBeOrchestrateHistory";
 
-export function transformAnalyzeSceHistories<Model extends ILlmSchema.Model>(
+export const transformAnalyzeSceHistories = <Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
-): Array<IMicroAgenticaHistoryJson> {
-  return [
+): IAutoBeOrchestrateHistory => ({
+  histories: [
     ...ctx
       .histories()
       .filter((h) => h.type === "userMessage" || h.type === "assistantMessage"),
@@ -33,5 +33,11 @@ export function transformAnalyzeSceHistories<Model extends ILlmSchema.Model>(
       `,
       created_at: new Date().toISOString(),
     },
-  ];
-}
+  ],
+  userMessage: StringUtil.trim`
+    Design a complete list of documents and user actors for this project.
+    Define user actors that can authenticate via API and create appropriate documentation files.
+    You must respect the number of documents specified by the user.
+    Note that the user's locale is in ${ctx.locale}.
+  `,
+});

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

@@ -1,4 +1,3 @@
-import { IAgenticaHistoryJson } from "@agentica/core";
 import { AutoBeAnalyzeScenarioEvent } from "@autobe/interface";
 import { AutoBeAnalyzeFile } from "@autobe/interface/src/histories/contents/AutoBeAnalyzeFile";
 import { StringUtil } from "@autobe/utils";
@@ -7,6 +6,7 @@ import { v7 } from "uuid";
 
 import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
 import { AutoBeContext } from "../../../context/AutoBeContext";
+import { IAutoBeOrchestrateHistory } from "../../../structures/IAutoBeOrchestrateHistory";
 
 export const transformAnalyzeWriteHistories = <Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
@@ -14,66 +14,67 @@ export const transformAnalyzeWriteHistories = <Model extends ILlmSchema.Model>(
     scenario: AutoBeAnalyzeScenarioEvent;
     file: AutoBeAnalyzeFile.Scenario;
   },
-): Array<
-  | IAgenticaHistoryJson.IUserMessage
-  | IAgenticaHistoryJson.IAssistantMessage
-  | IAgenticaHistoryJson.ISystemMessage
-> => [
-  ...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: v7(),
-    created_at: new Date().toISOString(),
-    type: "systemMessage",
-    text: AutoBeSystemPromptConstant.ANALYZE_WRITE,
-  },
-  {
-    id: v7(),
-    created_at: new Date().toISOString(),
-    type: "assistantMessage",
-    text: StringUtil.trim`
-      ## Language
-      
-      The language of the document is ${JSON.stringify(props.scenario.language ?? "en-US")}.
-      
-      ## Metadata
-      
-      Prefix name of the service to create is ${props.scenario.prefix}
-      and here is the list of the actors to reference.
+): IAutoBeOrchestrateHistory => ({
+  histories: [
+    ...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: v7(),
+      created_at: new Date().toISOString(),
+      type: "systemMessage",
+      text: AutoBeSystemPromptConstant.ANALYZE_WRITE,
+    },
+    {
+      id: v7(),
+      created_at: new Date().toISOString(),
+      type: "assistantMessage",
+      text: StringUtil.trim`
+        ## Language
+        
+        The language of the document is ${JSON.stringify(props.scenario.language ?? "en-US")}.
+        
+        ## Metadata
+        
+        Prefix name of the service to create is ${props.scenario.prefix}
+        and here is the list of the actors to reference.
 
-      \`\`\`json
-      ${JSON.stringify(props.scenario.actors)}
-      \`\`\`
+        \`\`\`json
+        ${JSON.stringify(props.scenario.actors)}
+        \`\`\`
 
-      Here is the entire list of the documents that would be published
-      in someday, and your task is to write a document of them:
-      
-      ## The other documents that would be published in someday
+        Here is the entire list of the documents that would be published
+        in someday, and your task is to write a document of them:
+        
+        ## The other documents that would be published in someday
 
-      \`\`\`json
-      ${JSON.stringify(
-        props.scenario.files.filter((f) => f.filename !== props.file.filename),
-      )}
-      \`\`\`
-      
-      ## The document to write
-      \`\`\`json
-      ${JSON.stringify(props.file)}
-      \`\`\`
-    `,
-  },
-];
+        \`\`\`json
+        ${JSON.stringify(
+          props.scenario.files.filter(
+            (f) => f.filename !== props.file.filename,
+          ),
+        )}
+        \`\`\`
+        
+        ## The document to write
+        \`\`\`json
+        ${JSON.stringify(props.file)}
+        \`\`\`
+      `,
+    },
+  ],
+  userMessage: "Write requirement analysis report.",
+});

package/src/orchestrate/analyze/orchestrateAnalyze.ts

@@ -43,6 +43,7 @@ export const orchestrateAnalyze = async <Model extends ILlmSchema.Model>(
     completed: 0,
   };
   const fileList: AutoBeAnalyzeFile[] = await executeCachedBatch(
+    ctx,
     scenario.files.map((file) => async (promptCacheKey) => {
       const event: AutoBeAnalyzeWriteEvent = await orchestrateAnalyzeWrite(
         ctx,
@@ -63,6 +64,7 @@ export const orchestrateAnalyze = async <Model extends ILlmSchema.Model>(
     completed: 0,
   };
   const newFiles: AutoBeAnalyzeFile[] = await executeCachedBatch(
+    ctx,
     fileList.map((file) => async (promptCacheKey) => {
       try {
         const event: AutoBeAnalyzeReviewEvent = await orchestrateAnalyzeReview(

package/src/orchestrate/analyze/orchestrateAnalyzeReview.ts

@@ -2,16 +2,18 @@ import { IAgenticaController } from "@agentica/core";
 import {
   AutoBeAnalyzeReviewEvent,
   AutoBeAnalyzeScenarioEvent,
+  AutoBeEventSource,
   AutoBeProgressEventBase,
 } from "@autobe/interface";
 import { AutoBeAnalyzeFile } from "@autobe/interface/src/histories/contents/AutoBeAnalyzeFile";
-import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
+import { ILlmApplication, ILlmSchema, IValidation } from "@samchon/openapi";
 import { IPointer } from "tstl";
 import typia from "typia";
 import { v7 } from "uuid";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
+import { AutoBePreliminaryController } from "../common/AutoBePreliminaryController";
 import { transformAnalyzeReviewHistories } from "./histories/transformAnalyzeReviewHistories";
 import { IAutoBeAnalyzeReviewApplication } from "./structures/IAutoBeAnalyzeReviewApplication";
 
@@ -25,75 +27,122 @@ export const orchestrateAnalyzeReview = async <Model extends ILlmSchema.Model>(
     promptCacheKey: string;
   },
 ): Promise<AutoBeAnalyzeReviewEvent> => {
-  const pointer: IPointer<IAutoBeAnalyzeReviewApplication.IProps | null> = {
-    value: null,
-  };
-  const { metric, tokenUsage } = await ctx.conversate({
-    source: "analyzeReview",
-    controller: createController({
-      model: ctx.model,
-      pointer,
-    }),
-    histories: [
-      ...transformAnalyzeReviewHistories(
-        ctx,
-        props.scenario,
-        props.allFiles,
-        props.myFile,
-      ),
-    ],
-    enforceFunctionCall: true,
-    promptCacheKey: props.promptCacheKey,
-    message: "Review the requirement document",
-  });
-  if (pointer.value === null)
-    throw new Error("Failed to extract review information.");
+  const preliminary: AutoBePreliminaryController<"analysisFiles"> =
+    new AutoBePreliminaryController({
+      application: typia.json.application<IAutoBeAnalyzeReviewApplication>(),
+      source: SOURCE,
+      kinds: ["analysisFiles"],
+      state: ctx.state(),
+      all: {
+        analysisFiles: props.allFiles,
+      },
+      local: {
+        analysisFiles: [props.myFile],
+      },
+    });
+  return await preliminary.orchestrate(ctx, async (out) => {
+    const pointer: IPointer<IAutoBeAnalyzeReviewApplication.IComplete | null> =
+      {
+        value: null,
+      };
+    const result: AutoBeContext.IResult<Model> = await ctx.conversate({
+      source: SOURCE,
+      controller: createController({
+        model: ctx.model,
+        pointer,
+        preliminary,
+      }),
+      enforceFunctionCall: true,
+      promptCacheKey: props.promptCacheKey,
+      ...transformAnalyzeReviewHistories(ctx, {
+        preliminary,
+        scenario: props.scenario,
+        myFile: props.myFile,
+      }),
+    });
+    if (pointer.value === null) return out(result)(null);
 
-  const event: AutoBeAnalyzeReviewEvent = {
-    type: "analyzeReview",
-    id: v7(),
-    file: props.myFile,
-    plan: pointer.value.plan,
-    review: pointer.value.review,
-    content: pointer.value.content,
-    tokenUsage,
-    metric,
-    total: props.progress.total,
-    completed: ++props.progress.completed,
-    step: (ctx.state().analyze?.step ?? -1) + 1,
-    created_at: new Date().toISOString(),
-  };
-  ctx.dispatch(event);
-  return event;
+    const event: AutoBeAnalyzeReviewEvent = {
+      type: SOURCE,
+      id: v7(),
+      file: props.myFile,
+      plan: pointer.value.plan,
+      review: pointer.value.review,
+      content: pointer.value.content,
+      tokenUsage: result.tokenUsage,
+      metric: result.metric,
+      total: props.progress.total,
+      completed: ++props.progress.completed,
+      step: (ctx.state().analyze?.step ?? -1) + 1,
+      created_at: new Date().toISOString(),
+    };
+    ctx.dispatch(event);
+    return out(result)(event);
+  });
 };
 
 function createController<Model extends ILlmSchema.Model>(props: {
   model: Model;
-  pointer: IPointer<IAutoBeAnalyzeReviewApplication.IProps | null>;
+  pointer: IPointer<IAutoBeAnalyzeReviewApplication.IComplete | null>;
+  preliminary: AutoBePreliminaryController<"analysisFiles">;
 }): IAgenticaController.IClass<Model> {
   assertSchemaModel(props.model);
 
+  const validate: Validator = (input) => {
+    const result: IValidation<IAutoBeAnalyzeReviewApplication.IProps> =
+      typia.validate<IAutoBeAnalyzeReviewApplication.IProps>(input);
+    if (result.success === false || result.data.request.type === "complete")
+      return result;
+    return props.preliminary.validate({
+      thinking: result.data.thinking,
+      request: result.data.request,
+    });
+  };
   const application: ILlmApplication<Model> = collection[
     props.model === "chatgpt"
       ? "chatgpt"
       : props.model === "gemini"
         ? "gemini"
         : "claude"
-  ] satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
+  ](
+    validate,
+  ) satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
   return {
     protocol: "class",
-    name: "Reviewer",
+    name: SOURCE,
     application,
     execute: {
-      review: (input) => {
-        props.pointer.value = input;
+      process: (input) => {
+        if (input.request.type === "complete")
+          props.pointer.value = input.request;
       },
     } satisfies IAutoBeAnalyzeReviewApplication,
   };
 }
 
 const collection = {
-  chatgpt: typia.llm.application<IAutoBeAnalyzeReviewApplication, "chatgpt">(),
-  claude: typia.llm.application<IAutoBeAnalyzeReviewApplication, "claude">(),
-  gemini: typia.llm.application<IAutoBeAnalyzeReviewApplication, "gemini">(),
+  chatgpt: (validate: Validator) =>
+    typia.llm.application<IAutoBeAnalyzeReviewApplication, "chatgpt">({
+      validate: {
+        process: validate,
+      },
+    }),
+  claude: (validate: Validator) =>
+    typia.llm.application<IAutoBeAnalyzeReviewApplication, "claude">({
+      validate: {
+        process: validate,
+      },
+    }),
+  gemini: (validate: Validator) =>
+    typia.llm.application<IAutoBeAnalyzeReviewApplication, "gemini">({
+      validate: {
+        process: validate,
+      },
+    }),
 };
+
+type Validator = (
+  input: unknown,
+) => IValidation<IAutoBeAnalyzeReviewApplication.IProps>;
+
+const SOURCE = "analyzeReview" satisfies AutoBeEventSource;

package/src/orchestrate/analyze/orchestrateAnalyzeScenario.ts

@@ -6,7 +6,6 @@ import {
   AutoBeAnalyzeScenarioEvent,
   AutoBeAssistantMessageHistory,
 } from "@autobe/interface";
-import { StringUtil } from "@autobe/utils";
 import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
 import { IPointer } from "tstl";
 import typia from "typia";
@@ -32,14 +31,8 @@ export const orchestrateAnalyzeScenario = async <
       model: ctx.model,
       build: (value) => (pointer.value = value),
     }),
-    histories: transformAnalyzeSceHistories(ctx),
     enforceFunctionCall: false,
-    message: StringUtil.trim`
-      Design a complete list of documents and user actors for this project.
-      Define user actors that can authenticate via API and create appropriate documentation files.
-      You must respect the number of documents specified by the user.
-      Note that the user's locale is in ${ctx.locale}.
-    `,
+    ...transformAnalyzeSceHistories(ctx),
   });
   if (histories.at(-1)?.type === "assistantMessage")
     return {
@@ -95,12 +88,6 @@ const collection = {
     IAutoBeAnalyzeScenarioApplication,
     "chatgpt"
   >(),
-  claude: typia.llm.application<
-    IAutoBeAnalyzeScenarioApplication,
-    "claude"
-  >(),
-  gemini: typia.llm.application<
-    IAutoBeAnalyzeScenarioApplication,
-    "gemini"
-  >(),
+  claude: typia.llm.application<IAutoBeAnalyzeScenarioApplication, "claude">(),
+  gemini: typia.llm.application<IAutoBeAnalyzeScenarioApplication, "gemini">(),
 };

package/src/orchestrate/analyze/orchestrateAnalyzeWrite.ts

@@ -34,10 +34,9 @@ export const orchestrateAnalyzeWrite = async <Model extends ILlmSchema.Model>(
       model: ctx.model,
       pointer,
     }),
-    histories: transformAnalyzeWriteHistories(ctx, props),
     enforceFunctionCall: true,
     promptCacheKey,
-    message: "Write requirement analysis report.",
+    ...transformAnalyzeWriteHistories(ctx, props),
   });
   if (pointer.value === null)
     throw new Error("The Analyze Agent failed to create the document.");