@autobe/agent 0.22.0 → 0.23.0

package/src/context/AutoBeTokenUsage.ts

@@ -162,6 +162,15 @@ export class AutoBeTokenUsage implements IAutoBeTokenUsageJson {
     }
   }
 
+  public assign(props: IAutoBeTokenUsageJson) {
+    this.facade.assign(props.facade);
+    this.analyze.assign(props.analyze);
+    this.prisma.assign(props.prisma);
+    this.interface.assign(props.interface);
+    this.test.assign(props.test);
+    this.realize.assign(props.realize);
+  }
+
   /**
    * Serialize token usage data to JSON format.
    *

package/src/context/AutoBeTokenUsageComponent.ts

@@ -101,6 +101,15 @@ export class AutoBeTokenUsageComponent
     }
   }
 
+  public assign(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;
+  }
+
   /**
    * Export token usage data as JSON.
    *

package/src/factory/consentFunctionCall.ts

@@ -32,7 +32,7 @@ export const consentFunctionCall = async (props: {
     vendor: props.vendor,
     config: {
       ...(props.config ?? []),
-      retry: props.config?.retry ?? AutoBeConfigConstant.DEFAULT_RETRY,
+      retry: props.config?.retry ?? AutoBeConfigConstant.RETRY,
       executor: {
         describe: null,
       },

package/src/factory/createAutoBeContext.ts

@@ -24,6 +24,7 @@ import {
   IAutoBeTokenUsageJson,
 } from "@autobe/interface";
 import { ILlmSchema } from "@samchon/openapi";
+import { Semaphore } from "tstl";
 import typia from "typia";
 import { v7 } from "uuid";
 
@@ -35,7 +36,10 @@ import { AutoBeTokenUsageComponent } from "../context/AutoBeTokenUsageComponent"
 import { IAutoBeApplication } from "../context/IAutoBeApplication";
 import { IAutoBeConfig } from "../structures/IAutoBeConfig";
 import { IAutoBeVendor } from "../structures/IAutoBeVendor";
+import { AutoBeTimeoutError } from "../utils/AutoBeTimeoutError";
+import { TimeoutConversation } from "../utils/TimeoutConversation";
 import { consentFunctionCall } from "./consentFunctionCall";
+import { getCriticalCompiler } from "./getCriticalCompiler";
 
 export const createAutoBeContext = <Model extends ILlmSchema.Model>(props: {
   model: Model;
@@ -49,16 +53,23 @@ export const createAutoBeContext = <Model extends ILlmSchema.Model>(props: {
   usage: () => AutoBeTokenUsage;
   dispatch: (event: AutoBeEvent) => Promise<void>;
 }): AutoBeContext<Model> => {
-  const retry: number =
-    props.config?.retry ?? AutoBeConfigConstant.DEFAULT_RETRY;
-  const locale: string = props.config.locale ?? "en-US";
+  const config: Required<Omit<IAutoBeConfig, "backoffStrategy" | "timezone">> =
+    {
+      retry: props.config.retry ?? AutoBeConfigConstant.RETRY,
+      locale: props.config.locale ?? "en-US",
+      timeout: props.config.timeout ?? AutoBeConfigConstant.TIMEOUT,
+    };
+  const critical: Semaphore = new Semaphore(2);
   return {
     model: props.model,
     vendor: props.vendor,
-    retry,
-    locale,
+    retry: config.retry,
+    locale: config.locale,
     compilerListener: props.compilerListener,
-    compiler: props.compiler,
+    compiler: async () => {
+      const compiler = await props.compiler();
+      return getCriticalCompiler(critical, compiler);
+    },
     files: props.files,
     histories: props.histories,
     state: props.state,
@@ -66,17 +77,25 @@ export const createAutoBeContext = <Model extends ILlmSchema.Model>(props: {
     dispatch: createDispatch(props),
     assistantMessage: (message) => {
       props.histories().push(message);
-      setTimeout(() => props.dispatch(message).catch(() => {}));
+      setTimeout(() => {
+        void props.dispatch(message).catch(() => {});
+      });
       return message;
     },
     conversate: async (next, closure) => {
+      const trial = {
+        request: 0,
+        response: 0,
+        timeout: 0,
+      };
       const execute = async (): Promise<AutoBeContext.IResult<Model>> => {
+        // CREATE AGENT
         const agent: MicroAgentica<Model> = new MicroAgentica<Model>({
           model: props.model,
           vendor: props.vendor,
           config: {
             ...(props.config ?? {}),
-            retry: props.config?.retry ?? AutoBeConfigConstant.DEFAULT_RETRY,
+            retry: props.config?.retry ?? AutoBeConfigConstant.RETRY,
             executor: {
               describe: null,
             },
@@ -84,6 +103,8 @@ export const createAutoBeContext = <Model extends ILlmSchema.Model>(props: {
           histories: next.histories,
           controllers: [next.controller],
         });
+
+        // ADD EVENT LISTENERS
         agent.on("request", async (event) => {
           if (next.enforceFunctionCall === true && event.body.tools)
             event.body.tool_choice = "required";
@@ -95,14 +116,16 @@ export const createAutoBeContext = <Model extends ILlmSchema.Model>(props: {
             ...event,
             type: "vendorRequest",
             source: next.source,
+            retry: trial.request++,
           });
         });
-        agent.on("response", (event) => {
+        agent.on("response", async (event) => {
           void props
             .dispatch({
               ...event,
               type: "vendorResponse",
               source: next.source,
+              retry: trial.response++,
             })
             .catch(() => {});
         });
@@ -121,15 +144,20 @@ export const createAutoBeContext = <Model extends ILlmSchema.Model>(props: {
               id: v7(),
               source: next.source,
               result: event.result,
+              life: event.life,
               created_at: event.created_at,
             })
             .catch(() => {});
         });
         if (closure) closure(agent);
 
-        const histories: MicroAgenticaHistory<Model>[] = await agent.conversate(
-          next.message,
-        );
+        // DO CONVERSATE
+        const result: TimeoutConversation.IResult<Model> =
+          await TimeoutConversation.process({
+            agent,
+            timeout: config.timeout,
+            message: next.message,
+          });
         const tokenUsage: IAutoBeTokenUsageJson.IComponent = agent
           .getTokenUsage()
           .toJSON().aggregate;
@@ -139,10 +167,25 @@ export const createAutoBeContext = <Model extends ILlmSchema.Model>(props: {
             STAGES.find((stage) => next.source.startsWith(stage)) ?? "analyze",
           ]);
 
-        if (
+        if (result.type === "error") throw result.error;
+        else if (result.type === "timeout") {
+          void props
+            .dispatch({
+              type: "vendorTimeout",
+              id: v7(),
+              source: next.source,
+              timeout: config.timeout,
+              retry: trial.timeout++,
+              created_at: new Date().toISOString(),
+            })
+            .catch(() => {});
+          throw result.error;
+        } else if (
           true === next.enforceFunctionCall &&
           false ===
-            histories.some((h) => h.type === "execute" && h.success === true)
+            result.histories.some(
+              (h) => h.type === "execute" && h.success === true,
+            )
         ) {
           const failure = () => {
             throw new Error(
@@ -150,7 +193,7 @@ export const createAutoBeContext = <Model extends ILlmSchema.Model>(props: {
             );
           };
           const last: MicroAgenticaHistory<Model> | undefined =
-            histories.at(-1);
+            result.histories.at(-1);
           if (
             last?.type === "assistantMessage" &&
             last.text.trim().length !== 0
@@ -195,10 +238,14 @@ export const createAutoBeContext = <Model extends ILlmSchema.Model>(props: {
           }
           failure();
         }
-        return { histories, tokenUsage };
+        return {
+          histories: result.histories,
+          tokenUsage,
+        };
       };
-      if (next.enforceFunctionCall === true) return forceRetry(execute, retry);
-      else return execute();
+      if (next.enforceFunctionCall === true)
+        return await forceRetry(execute, config.retry);
+      else return await execute();
     },
   };
 };
@@ -312,7 +359,7 @@ const createDispatch = (props: {
           step: event.step,
         } satisfies AutoBeRealizeHistory,
       }) as AutoBeContext.DispatchHistory<Event>;
-    props.dispatch(event).catch(() => {});
+    void props.dispatch(event).catch(() => {});
     return null as AutoBeContext.DispatchHistory<Event>;
   };
 };
@@ -333,7 +380,7 @@ const transformAndDispatch = <
 }): NonNullable<AutoBeContext.DispatchHistory<Event>> => {
   props.histories().push(props.history);
   props.state()[props.history.type] = props.history as any;
-  props.dispatch(props.event).catch(() => {});
+  void props.dispatch(props.event).catch(() => {});
   return props.history;
 };
 
@@ -346,6 +393,7 @@ const forceRetry = async <T>(
     try {
       return await task();
     } catch (e) {
+      if (e instanceof AutoBeTimeoutError) throw e;
       error = e;
     }
   throw error;

package/src/factory/getCriticalCompiler.ts

@@ -0,0 +1,47 @@
+import { IAutoBeCompiler } from "@autobe/interface";
+import { Semaphore } from "tstl";
+
+export const getCriticalCompiler = (
+  critical: Semaphore,
+  compiler: IAutoBeCompiler,
+): IAutoBeCompiler => {
+  const lock = async (func: () => Promise<any>) => {
+    await critical.acquire();
+    try {
+      return await func();
+    } finally {
+      await critical.release();
+    }
+  };
+  return {
+    prisma: {
+      compile: (props) => lock(() => compiler.prisma.compile(props)),
+      validate: (app) => lock(() => compiler.prisma.validate(app)),
+      write: (app, dmbs) => lock(() => compiler.prisma.write(app, dmbs)),
+    },
+    interface: {
+      write: (doc) => lock(() => compiler.interface.write(doc)),
+      transform: (doc) => lock(() => compiler.interface.transform(doc)),
+      invert: (doc) => lock(() => compiler.interface.invert(doc)),
+      getTemplate: () => lock(() => compiler.interface.getTemplate()),
+    },
+    typescript: {
+      compile: (props) => lock(() => compiler.typescript.compile(props)),
+      getExternal: (location) =>
+        lock(() => compiler.typescript.getExternal(location)),
+      beautify: (code) => lock(() => compiler.typescript.beautify(code)),
+    },
+    test: {
+      compile: (props) => lock(() => compiler.test.compile(props)),
+      validate: (props) => lock(() => compiler.test.validate(props)),
+      write: (props) => lock(() => compiler.test.write(props)),
+      getExternal: () => lock(() => compiler.test.getExternal()),
+      getTemplate: () => lock(() => compiler.test.getTemplate()),
+    },
+    realize: {
+      controller: (props) => lock(() => compiler.realize.controller(props)),
+      test: (props) => lock(() => compiler.realize.test(props)),
+      getTemplate: () => lock(() => compiler.realize.getTemplate()),
+    },
+  };
+};

package/src/orchestrate/analyze/orchestrateAnalyzeWrite.ts

@@ -28,7 +28,7 @@ export const orchestrateAnalyzeWrite = async <Model extends ILlmSchema.Model>(
   const pointer: IPointer<IAutoBeAnalyzeWriteApplication.IProps | null> = {
     value: null,
   };
-  const { histories, tokenUsage } = await ctx.conversate({
+  const { tokenUsage } = await ctx.conversate({
     source: "analyzeWrite",
     controller: createController<Model>({
       model: ctx.model,
@@ -39,10 +39,8 @@ export const orchestrateAnalyzeWrite = async <Model extends ILlmSchema.Model>(
     promptCacheKey,
     message: "Write requirement analysis report.",
   });
-  if (pointer.value === null) {
-    console.log(JSON.stringify(histories, null, 2));
+  if (pointer.value === null)
     throw new Error("The Analyze Agent failed to create the document.");
-  }
 
   const event: AutoBeAnalyzeWriteEvent = {
     type: "analyzeWrite",

package/src/orchestrate/common/histories/transformCommonCorrectCastingHistories.ts

@@ -0,0 +1,43 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import { IAutoBeTypeScriptCompileResult } from "@autobe/interface";
+import { StringUtil } from "@autobe/utils";
+import { v7 } from "uuid";
+
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+
+interface IFailure {
+  diagnostics: IAutoBeTypeScriptCompileResult.IDiagnostic[];
+  script: string;
+}
+
+export const transformCommonCorrectCastingHistories = (
+  failures: IFailure[],
+): Array<
+  IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
+> => [
+  {
+    id: v7(),
+    created_at: new Date().toISOString(),
+    type: "systemMessage",
+    text: AutoBeSystemPromptConstant.COMMON_CORRECT_CASTING,
+  },
+  ...failures.map(
+    (f, i, array) =>
+      ({
+        id: v7(),
+        created_at: new Date().toISOString(),
+        type: "assistantMessage",
+        text: StringUtil.trim`
+      # ${i === array.length - 1 ? "Latest Failure" : "Previous Failure"}
+      ## Generated TypeScript Code
+      \`\`\`typescript
+      ${f.script}
+      \`\`\`
+      ## Compile Errors
+      \`\`\`json
+      ${JSON.stringify(f.diagnostics)}
+      \`\`\`
+    `,
+      }) satisfies IAgenticaHistoryJson.IAssistantMessage,
+  ),
+];

package/src/orchestrate/common/orchestrateCommonCorrectCasting.ts

@@ -0,0 +1,170 @@
+import {
+  AutoBeRealizeCorrectEvent,
+  AutoBeRealizeValidateEvent,
+  AutoBeTestCorrectEvent,
+  AutoBeTestValidateEvent,
+  IAutoBeTokenUsageJson,
+  IAutoBeTypeScriptCompileResult,
+} from "@autobe/interface";
+import { StringUtil } from "@autobe/utils";
+import { ILlmApplication, ILlmController, ILlmSchema } from "@samchon/openapi";
+import { IPointer } from "tstl";
+import typia from "typia";
+
+import { AutoBeContext } from "../../context/AutoBeContext";
+import { assertSchemaModel } from "../../context/assertSchemaModel";
+import { transformCommonCorrectCastingHistories } from "./histories/transformCommonCorrectCastingHistories";
+import { IAutoBeCommonCorrectCastingApplication } from "./structures/IAutoBeCommonCorrectCastingApplication";
+
+interface IFactoryProps<
+  ValidateEvent extends AutoBeTestValidateEvent | AutoBeRealizeValidateEvent,
+  CorrectEvent extends AutoBeTestCorrectEvent | AutoBeRealizeCorrectEvent,
+> {
+  validate(script: string): Promise<ValidateEvent>;
+  correct(next: {
+    failure: IAutoBeTypeScriptCompileResult.IFailure;
+    think: string;
+    draft: string;
+    review: string | undefined;
+    final: string | undefined;
+    tokenUsage: IAutoBeTokenUsageJson.IComponent;
+  }): CorrectEvent;
+  script(event: ValidateEvent): string;
+  source: "testCorrect" | "realizeCorrect";
+}
+
+export const orchestrateCommonCorrectCasting = async <
+  Model extends ILlmSchema.Model,
+  ValidateEvent extends AutoBeTestValidateEvent | AutoBeRealizeValidateEvent,
+  CorrectEvent extends AutoBeTestCorrectEvent | AutoBeRealizeCorrectEvent,
+>(
+  ctx: AutoBeContext<Model>,
+  factory: IFactoryProps<ValidateEvent, CorrectEvent>,
+  script: string,
+): Promise<ValidateEvent> => {
+  const event: ValidateEvent = await factory.validate(script);
+  return await predicate(ctx, factory, [], script, event, ctx.retry);
+};
+
+const predicate = async <
+  Model extends ILlmSchema.Model,
+  ValidateEvent extends AutoBeTestValidateEvent | AutoBeRealizeValidateEvent,
+  CorrectEvent extends AutoBeTestCorrectEvent | AutoBeRealizeCorrectEvent,
+>(
+  ctx: AutoBeContext<Model>,
+  factory: IFactoryProps<ValidateEvent, CorrectEvent>,
+  failures: ValidateEvent[],
+  script: string,
+  event: ValidateEvent,
+  life: number,
+): Promise<ValidateEvent> => {
+  if (event.result.type === "failure") {
+    ctx.dispatch(event);
+    return await correct(ctx, factory, failures, script, event, life - 1);
+  }
+  return event;
+};
+
+const correct = async <
+  Model extends ILlmSchema.Model,
+  ValidateEvent extends AutoBeTestValidateEvent | AutoBeRealizeValidateEvent,
+  CorrectEvent extends AutoBeTestCorrectEvent | AutoBeRealizeCorrectEvent,
+>(
+  ctx: AutoBeContext<Model>,
+  factory: IFactoryProps<ValidateEvent, CorrectEvent>,
+  failures: ValidateEvent[],
+  script: string,
+  event: ValidateEvent,
+  life: number,
+): Promise<ValidateEvent> => {
+  if (event.result.type !== "failure") return event;
+  else if (life < 0) return event;
+
+  const pointer: IPointer<
+    IAutoBeCommonCorrectCastingApplication.IProps | false | null
+  > = {
+    value: null,
+  };
+  const { tokenUsage } = await ctx.conversate({
+    source: factory.source,
+    histories: transformCommonCorrectCastingHistories(
+      [...failures, event].map((e) => ({
+        diagnostics: (e.result as IAutoBeTypeScriptCompileResult.IFailure)
+          .diagnostics,
+        script: factory.script(e),
+      })),
+    ),
+    controller: createController({
+      model: ctx.model,
+      then: (next) => {
+        pointer.value = next;
+      },
+      reject: () => {
+        pointer.value = false;
+      },
+    }),
+    enforceFunctionCall: true,
+    message: StringUtil.trim`
+      Fix the TypeScript casting problems to resolve the compilation error.
+
+      You don't need to explain me anything, but just fix or give it up 
+      immediately without any hesitation, explanation, and questions.
+    `,
+  });
+  if (pointer.value === null) throw new Error("Failed to correct test code.");
+  else if (pointer.value === false) return event;
+
+  ctx.dispatch(
+    factory.correct({
+      failure: event.result,
+      think: pointer.value.think,
+      draft: pointer.value.draft,
+      review: pointer.value.revise.review,
+      final: pointer.value.revise.final,
+      tokenUsage,
+    }),
+  );
+  return await predicate(
+    ctx,
+    factory,
+    [...failures, event],
+    script,
+    await factory.validate(pointer.value.revise.final),
+    life - 1,
+  );
+};
+
+const createController = <Model extends ILlmSchema.Model>(props: {
+  model: Model;
+  then: (next: IAutoBeCommonCorrectCastingApplication.IProps) => void;
+  reject: () => void;
+}): ILlmController<Model> => {
+  assertSchemaModel(props.model);
+  const application = collection[
+    props.model === "chatgpt" ? "chatgpt" : "claude"
+  ] satisfies ILlmApplication<any> as any as ILlmApplication<Model>;
+  return {
+    protocol: "class",
+    name: "correctInvalidRequest",
+    application,
+    execute: {
+      rewrite: (next) => {
+        props.then(next);
+      },
+      reject: () => {
+        props.reject();
+      },
+    } satisfies IAutoBeCommonCorrectCastingApplication,
+  };
+};
+
+const collection = {
+  chatgpt: typia.llm.application<
+    IAutoBeCommonCorrectCastingApplication,
+    "chatgpt"
+  >(),
+  claude: typia.llm.application<
+    IAutoBeCommonCorrectCastingApplication,
+    "claude"
+  >(),
+};

package/src/orchestrate/common/structures/IAutoBeCommonCorrectCastingApplication.ts

@@ -0,0 +1,127 @@
+/**
+ * Function calling interface for fixing TypeScript type casting and assignment errors.
+ *
+ * This interface is used by the CommonCorrectCasting agent to fix TypeScript
+ * compilation errors related to type casting and type assignment incompatibilities
+ * in any TypeScript code, not limited to e2e tests.
+ *
+ * The agent handles various type casting issues including:
+ *
+ * - **Typia tag type incompatibilities**: Format tag mismatches (e.g., Format<"uuid"> 
+ *   vs Pattern<...>), type constraint incompatibilities (e.g., Type<"int32"> vs 
+ *   Type<"int32"> & Minimum<0>), nullable type conversions with tags
+ * - **Date to string conversions**: Date to string, Date to string & Format<"date-time">, 
+ *   nullable Date handling
+ * - **Nullable and undefined type assignments**: Exhaustive type narrowing for 
+ *   T | null | undefined patterns
+ * - **String to literal type assignments**: Converting general string to literal 
+ *   union types (e.g., "pending" | "approved" | "rejected")
+ * - **Optional chaining with union types**: Handling boolean | undefined results 
+ *   from array methods like includes()
+ * - **Type narrowing "no overlap" errors**: Removing redundant comparisons after 
+ *   TypeScript's control flow analysis
+ *
+ * @author Samchon
+ */
+export interface IAutoBeCommonCorrectCastingApplication {
+  /**
+   * Rewrite function to fix type casting and assignment errors.
+   *
+   * This function is called when the agent detects any type casting or assignment
+   * related compilation error patterns.
+   *
+   * The agent applies various fix strategies based on the error type:
+   *
+   * - **Typia tag incompatibilities**: Uses `satisfies ... as ...` pattern to strip 
+   *   incompatible tags, or `typia.assert<T>()` as a last resort
+   * - **Date conversions**: Uses `.toISOString()` method for Date to string conversions
+   * - **Nullable type narrowing**: Applies exhaustive checks (e.g., !== null && !== undefined)
+   * - **typia.assert vs assertGuard**: Uses assert for value assignment, assertGuard 
+   *   for type narrowing
+   * - **Literal type conversions**: Uses `typia.assert<T>()` for runtime validation
+   * - **Optional chaining results**: Uses `=== true` or `??` operators
+   * - **"No overlap" errors**: Removes redundant comparisons
+   *
+   * @param props - The analysis and correction properties
+   * @param props.think - Analysis of the type casting issue found
+   * @param props.draft - Initial corrected code with type fixes applied
+   * @param props.revise - Review of corrections and final code
+   */
+  rewrite(props: IAutoBeCommonCorrectCastingApplication.IProps): void;
+
+  /**
+   * Reject function when error is not related to type casting or assignment.
+   *
+   * This function is called when the compilation error is unrelated to type 
+   * casting issues (e.g., missing imports, syntax errors, undefined variables), 
+   * indicating the error should be handled by a different agent.
+   */
+  reject(): void;
+}
+export namespace IAutoBeCommonCorrectCastingApplication {
+  /**
+   * Properties for the rewrite function containing the type casting error
+   * analysis and correction workflow.
+   */
+  export interface IProps {
+    /**
+     * Initial analysis of the type casting or assignment error.
+     *
+     * Contains the agent's analysis of the specific type mismatch pattern:
+     *
+     * - Type of casting error (tag incompatibility, nullable assignment, literal 
+     *   type conversion, etc.)
+     * - Whether nullable or undefined types are involved
+     * - If Date to string conversions are needed
+     * - The chosen fix strategy for the specific error type
+     */
+    think: string;
+
+    /**
+     * Draft correction with initial type casting fixes.
+     *
+     * The code after applying the first round of fixes:
+     *
+     * - Satisfies patterns for tag stripping
+     * - Date.toISOString() conversions where needed
+     * - Nullable type narrowing checks
+     * - Literal type assertions
+     * - Optional chaining result handling
+     */
+    draft: string;
+
+    /**
+     * Review and finalization of type casting corrections.
+     *
+     * Contains the review of applied corrections and the final code with all
+     * type casting issues resolved while preserving type safety and validation intent.
+     */
+    revise: IReviseProps;
+  }
+
+  /** Properties for the revision phase of type casting corrections. */
+  export interface IReviseProps {
+    /**
+     * Review of the type casting correction patterns applied.
+     *
+     * Explains which correction strategies were used:
+     *
+     * - Which satisfies patterns were applied for tag issues
+     * - Where typia.assert or assertGuard was used
+     * - How Date conversions were handled
+     * - What nullable type narrowing was applied
+     * - How literal type conversions were resolved
+     * - Confirmation that all type casting issues are resolved
+     */
+    review: string;
+
+    /**
+     * Final corrected code with all type casting issues resolved.
+     *
+     * The complete code ready for TypeScript compilation, with all type casting
+     * and assignment errors properly fixed using appropriate patterns while
+     * maintaining type safety and the original validation logic.
+     */
+    final: string;
+  }
+}

package/src/orchestrate/interface/histories/transformInterfaceEndpointsReviewHistories.ts

@@ -1,6 +1,6 @@
 import { IAgenticaHistoryJson } from "@agentica/core";
 import { AutoBeOpenApi } from "@autobe/interface";
-import { v4 } from "uuid";
+import { v7 } from "uuid";
 
 import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
 import { AutoBeState } from "../../../context/AutoBeState";
@@ -14,13 +14,13 @@ export const transformInterfaceEndpointsReviewHistories = (
 > => [
   {
     type: "systemMessage",
-    id: v4(),
+    id: v7(),
     created_at: new Date().toISOString(),
     text: AutoBeSystemPromptConstant.INTERFACE_ENDPOINT,
   },
   ...transformInterfaceAssetHistories(state),
   {
-    id: v4(),
+    id: v7(),
     type: "assistantMessage",
     text: [
       "Below are endpoints generated by your request.",
@@ -31,7 +31,7 @@ export const transformInterfaceEndpointsReviewHistories = (
     created_at: new Date().toISOString(),
   },
   {
-    id: v4(),
+    id: v7(),
     type: "systemMessage",
     text: AutoBeSystemPromptConstant.INTERFACE_ENDPOINTS_REVIEW,
     created_at: new Date().toISOString(),