@autobe/agent 0.18.0 → 0.20.0

package/src/context/AutoBeContext.ts

@@ -71,6 +71,7 @@ export namespace AutoBeContext {
     histories: Array<IMicroAgenticaHistoryJson>;
     enforceFunctionCall: boolean;
     message: string;
+    promptCacheKey?: string;
   }
   export interface IResult<Model extends ILlmSchema.Model> {
     histories: MicroAgenticaHistory<Model>[];

package/src/context/AutoBeTokenUsageComponent.ts

@@ -195,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,129 @@
+import {
+  IAgenticaHistoryJson,
+  MicroAgentica,
+  MicroAgenticaHistory,
+} from "@agentica/core";
+import {
+  AutoBeConsentFunctionCallEvent,
+  AutoBeEvent,
+  AutoBeEventSource,
+} from "@autobe/interface";
+import { IPointer } from "tstl";
+import typia from "typia";
+import { v7 } 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: v7(),
+        type: "systemMessage",
+        text: AutoBeSystemPromptConstant.CONSENT_FUNCTION_CALL,
+        created_at: new Date().toISOString(),
+      } satisfies IAgenticaHistoryJson.ISystemMessage,
+      {
+        id: v7(),
+        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",
+    id: v7(),
+    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/createAutoBeContext.ts

@@ -25,14 +25,16 @@ import {
 } from "@autobe/interface";
 import { ILlmSchema } from "@samchon/openapi";
 import typia from "typia";
-import { v4 } from "uuid";
+import { v7 } 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;
@@ -75,12 +77,48 @@ export const createAutoBeContext = <Model extends ILlmSchema.Model>(props: {
         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;
+      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;
+        if (next.promptCacheKey)
+          event.body.prompt_cache_key = next.promptCacheKey;
+        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",
+            id: v7(),
+            source: next.source,
+            result: event.result,
+            created_at: event.created_at,
+          })
+          .catch(() => {});
+      });
+
       const histories: MicroAgenticaHistory<Model>[] = await agent.conversate(
         next.message,
       );
@@ -92,16 +130,65 @@ export const createAutoBeContext = <Model extends ILlmSchema.Model>(props: {
         .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`,
-        );
+        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());
+    if (next.enforceFunctionCall === true) return forceRetry(execute);
     else return execute();
   },
 });
@@ -134,7 +221,7 @@ const createDispatch = (props: {
         event,
         history: {
           type: "analyze",
-          id: v4(),
+          id: v7(),
           reason: analyzeStart?.reason ?? "",
           prefix: event.prefix,
           roles: event.roles,
@@ -152,7 +239,7 @@ const createDispatch = (props: {
         event,
         history: {
           type: "prisma",
-          id: v4(),
+          id: v7(),
           reason: prismaStart?.reason ?? "",
           schemas: event.schemas,
           result: event.result,
@@ -170,8 +257,9 @@ const createDispatch = (props: {
         event,
         history: {
           type: "interface",
-          id: v4(),
+          id: v7(),
           reason: interfaceStart?.reason ?? "",
+          authorizations: event.authorizations,
           document: event.document,
           created_at: interfaceStart?.created_at ?? new Date().toISOString(),
           completed_at: new Date().toISOString(),
@@ -186,7 +274,7 @@ const createDispatch = (props: {
         event,
         history: {
           type: "test",
-          id: v4(),
+          id: v7(),
           reason: testStart?.reason ?? "",
           files: event.files,
           compiled: event.compiled,
@@ -203,7 +291,7 @@ const createDispatch = (props: {
         event,
         history: {
           type: "realize",
-          id: v4(),
+          id: v7(),
           reason: realizeStart?.reason ?? "",
           authorizations: event.authorizations,
           functions: event.functions,
@@ -241,10 +329,10 @@ const transformAndDispatch = <
 
 const forceRetry = async <T>(
   task: () => Promise<T>,
-  count: number = 2,
+  count: number = 3,
 ): Promise<T> => {
   let error: unknown = undefined;
-  for (let i: number = 0; i <= count; ++i)
+  for (let i: number = 0; i < count; ++i)
     try {
       return await task();
     } catch (e) {

package/src/orchestrate/analyze/histories/transformAnalyzeReviewHistories.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 { StringUtil } from "@autobe/utils";
+import { ILlmSchema } from "@samchon/openapi";
+import { v7 } from "uuid";
+
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+import { AutoBeContext } from "../../../context/AutoBeContext";
+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 [
+    ...transformAnalyzeWriteHistories(ctx, scenario, myFile).slice(0, -1),
+    {
+      id: v7(),
+      created_at: new Date().toISOString(),
+      type: "systemMessage",
+      text: AutoBeSystemPromptConstant.ANALYZE_REVIEW,
+    },
+    {
+      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.
+        
+        Note that, never review others.
+      `,
+    },
+  ];
+};

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

@@ -1,6 +1,7 @@
 import { IMicroAgenticaHistoryJson } from "@agentica/core";
+import { StringUtil } from "@autobe/utils";
 import { ILlmSchema } from "@samchon/openapi";
-import { v4 } from "uuid";
+import { v7 } from "uuid";
 
 import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
 import { AutoBeContext } from "../../../context/AutoBeContext";
@@ -13,21 +14,23 @@ export function transformAnalyzeSceHistories<Model extends ILlmSchema.Model>(
       .histories()
       .filter((h) => h.type === "userMessage" || h.type === "assistantMessage"),
     {
-      id: v4(),
+      id: v7(),
       type: "systemMessage",
       text: AutoBeSystemPromptConstant.ANALYZE_SCENARIO,
       created_at: new Date().toISOString(),
     },
     {
-      id: v4(),
+      id: v7(),
       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"),
+      text: StringUtil.trim`
+        > 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}
+      `,
       created_at: new Date().toISOString(),
     },
   ];

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

@@ -1,56 +1,77 @@
 import { IAgenticaHistoryJson } from "@agentica/core";
 import { AutoBeAnalyzeScenarioEvent } from "@autobe/interface";
 import { AutoBeAnalyzeFile } from "@autobe/interface/src/histories/contents/AutoBeAnalyzeFile";
-import { v4 } from "uuid";
+import { StringUtil } from "@autobe/utils";
+import { ILlmSchema } from "@samchon/openapi";
+import { v7 } from "uuid";
 
 import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+import { AutoBeContext } from "../../../context/AutoBeContext";
 
-export const transformAnalyzeWriteHistories = (
+export const transformAnalyzeWriteHistories = <Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
   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"),
-    },
-  ];
-};
+  | 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(scenario.language ?? "en-US")}.
+      
+      ## 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)}
+      \`\`\`
+    `,
+  },
+];