@autobe/agent 0.11.2 → 0.12.0

package/src/orchestrate/realize/transformRealizeCoderHistories.ts

@@ -12,7 +12,6 @@ export const transformRealizeCoderHistories = (
   props: RealizePlannerOutput,
   artifacts: IAutoBeTestScenarioArtifacts,
   previous: string | null,
-  total: IAutoBeTypeScriptCompileResult.IDiagnostic[],
   diagnostics: IAutoBeTypeScriptCompileResult.IDiagnostic[],
 ): Array<
   IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
@@ -90,31 +89,7 @@ export const transformRealizeCoderHistories = (
       id: v4(),
       created_at: new Date().toISOString(),
       type: "systemMessage",
-      text: AutoBeSystemPromptConstant.REALIZE_CODER,
-    },
-    {
-      id: v4(),
-      created_at: new Date().toISOString(),
-      type: "systemMessage",
-      text: AutoBeSystemPromptConstant.REALIZE_CODER_TYPESCRIPT,
-    },
-    {
-      id: v4(),
-      created_at: new Date().toISOString(),
-      type: "systemMessage",
-      text: AutoBeSystemPromptConstant.REALIZE_CODER_PRISMA,
-    },
-    {
-      id: v4(),
-      created_at: new Date().toISOString(),
-      type: "systemMessage",
-      text: AutoBeSystemPromptConstant.REALIZE_CODER_BROWSER,
-    },
-    {
-      id: v4(),
-      created_at: new Date().toISOString(),
-      type: "systemMessage",
-      text: AutoBeSystemPromptConstant.REALIZE_CODER_TYPIA,
+      text: AutoBeSystemPromptConstant.REALIZE_CODER_TOTAL,
     },
     {
       id: v4(),
@@ -125,8 +100,8 @@ export const transformRealizeCoderHistories = (
         JSON.stringify(state.prisma.schemas),
       )
         .replaceAll(`{artifacts_sdk}`, JSON.stringify(artifacts.sdk))
-        .replaceAll(`{artifacts_dto}`, JSON.stringify(artifacts.dto))
-        .replaceAll(`{artifacts_document}`, JSON.stringify(artifacts.document)),
+        .replaceAll(`{artifacts_dto}`, JSON.stringify(artifacts.dto)),
+      // .replaceAll(`{artifacts_document}`, JSON.stringify(artifacts.document)),
     },
     ...(previous !== null
       ? [
@@ -138,7 +113,7 @@ export const transformRealizeCoderHistories = (
               `{code}`,
               previous,
             )
-              .replaceAll("{total_diagnostics}", JSON.stringify(total))
+              // .replaceAll("{total_diagnostics}", JSON.stringify(total))
               .replaceAll("{current_diagnostics}", JSON.stringify(diagnostics)),
           } as const,
         ]
@@ -156,5 +131,23 @@ export const transformRealizeCoderHistories = (
         "```",
       ].join("\n"),
     },
+    {
+      id: v4(),
+      created_at: new Date().toISOString(),
+      type: "assistantMessage",
+      text: [
+        `I understand your request.`,
+        ``,
+        `To summarize:`,
+        `- I must **never use the native \`Date\` type** in any code or type definitions.`,
+        `- Instead, all date and datetime values must be handled as \`string & tags.Format<'date-time'>\`.`,
+        `- This rule is **strict** and applies everywhere, including domain types, API inputs/outputs, and Prisma models.`,
+        `- Even if a library or tool returns a \`Date\`, I must convert it to the correct string format before use.`,
+        ``,
+        `Especially regarding the \`Date\` type: I understand that using it can lead to type inconsistency and runtime issues, so I will completely avoid it in all circumstances.`,
+        ``,
+        `I'll make sure to follow all these rules strictly. Let’s proceed with this in mind.`,
+      ].join("\n"),
+    },
   ];
 };

package/src/orchestrate/realize/transformRealizeDecorator.ts

@@ -0,0 +1,37 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import { ILlmSchema } from "@samchon/openapi";
+import { v4 } from "uuid";
+
+import { AutoBeSystemPromptConstant } from "../../constants/AutoBeSystemPromptConstant";
+import { AutoBeContext } from "../../context/AutoBeContext";
+
+export const transformRealizeDecoratorHistories = (
+  ctx: AutoBeContext<ILlmSchema.Model>,
+  role: string,
+): Array<
+  IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
+> => {
+  return [
+    {
+      id: v4(),
+      created_at: new Date().toISOString(),
+      type: "systemMessage",
+      text: AutoBeSystemPromptConstant.REALIZE_DECORATOR,
+    },
+    {
+      id: v4(),
+      created_at: new Date().toISOString(),
+      type: "systemMessage",
+      text: [
+        "## Role",
+        "",
+        role,
+        "",
+        "## Prisma Schema",
+        "",
+        JSON.stringify(ctx.state().prisma?.schemas, null, 2),
+        "",
+      ].join("\n"),
+    },
+  ];
+};

package/src/orchestrate/realize/transformRealizeDecoratorCorrectHistories.ts

@@ -0,0 +1,58 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import { IAutoBeTypeScriptCompileResult } from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+import { v4 } from "uuid";
+
+import { AutoBeSystemPromptConstant } from "../../constants/AutoBeSystemPromptConstant";
+import { AutoBeContext } from "../../context/AutoBeContext";
+import { IAutoBeRealizeDecoratorApplication } from "./structures/IAutoBeRealizeDecoratorApplication";
+
+export const transformRealizeDecoratorCorrectHistories = (
+  ctx: AutoBeContext<ILlmSchema.Model>,
+  result: IAutoBeRealizeDecoratorApplication.IProps,
+  templateFiles: Record<string, string>,
+  diagnostics: IAutoBeTypeScriptCompileResult.IDiagnostic[],
+): Array<
+  IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
+> => {
+  return [
+    {
+      id: v4(),
+      created_at: new Date().toISOString(),
+      type: "systemMessage",
+      text: AutoBeSystemPromptConstant.REALIZE_DECORATOR_CORRECT,
+    },
+    {
+      id: v4(),
+      created_at: new Date().toISOString(),
+      type: "assistantMessage",
+      text: [
+        "## Generated TypeScript Code",
+        "",
+        "```json",
+        `${JSON.stringify(result, null, 2)}`,
+        "```",
+        "",
+        "## Prisma Schema",
+        "",
+        "```json",
+        `${JSON.stringify(ctx.state().prisma?.schemas, null, 2)}`,
+        "```",
+        "",
+        "## File Paths",
+        "",
+        Object.keys(templateFiles)
+          .map((path) => `- ${path}`)
+          .join("\n"),
+        "",
+        "## Compile Errors",
+        "",
+        "Fix the compilation error in the provided code.",
+        "",
+        "```json",
+        JSON.stringify(diagnostics, null, 2),
+        "```",
+      ].join("\n"),
+    },
+  ];
+};

package/src/orchestrate/realize/writeCodeUntilCompilePassed.ts

@@ -19,7 +19,7 @@ export async function writeCodeUntilCompilePassed<
 >(
   ctx: AutoBeContext<Model>,
   ops: AutoBeOpenApi.IOperation[],
-  retry: number = 5,
+  retry: number = 3,
 ): Promise<
   Pick<
     IAutoBeRealizeCoderApplication.RealizeCoderOutput,
@@ -45,14 +45,20 @@ export async function writeCodeUntilCompilePassed<
     total: [],
   };
 
+  ops = ops.filter((_el, i) => i < 10);
   for (let i = 0; i < retry; i++) {
+    const targets = ops.filter((op) =>
+      shouldProcessOperation(op, diagnostics.current),
+    );
+
+    const metadata = { total: targets.length, count: 0 };
     const generatedCodes: (
       | IAutoBeRealizeCompile.Success
       | IAutoBeRealizeCompile.Fail
     )[] = await Promise.all(
-      ops
-        .filter((op) => shouldProcessOperation(op, diagnostics.current))
-        .map((op) => process(ctx, op, diagnostics, entireCodes)),
+      targets.map((op) => {
+        return process(ctx, metadata, op, diagnostics, entireCodes);
+      }),
     );
 
     for (const c of generatedCodes) {
@@ -93,7 +99,11 @@ export async function writeCodeUntilCompilePassed<
       diagnostics.current = compiled.diagnostics;
       diagnostics.total = [...diagnostics.total, ...compiled.diagnostics];
 
-      console.log(JSON.stringify(diagnostics, null, 2), i);
+      console.log(
+        JSON.stringify(diagnostics.current, null, 2),
+        `현재 에러의 수: ${diagnostics.current.length}\n`,
+        `현재 시도 수: ${i}`,
+      );
     }
   }
 
@@ -129,6 +139,7 @@ async function loadTemplateFiles(
 
 async function process<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
+  metadata: { total: number; count: number },
   op: AutoBeOpenApi.IOperation,
   diagnostics: IAutoBeRealizeCompile.CompileDiagnostics,
   entireCodes: IAutoBeRealizeCompile.FileContentMap,
@@ -136,22 +147,36 @@ async function process<Model extends ILlmSchema.Model>(
   const result = await pipe(
     op,
     (op) => orchestrateRealizePlanner(ctx, op),
-    (p) => {
+    async (p) => {
       const filename = `src/providers/${p.functionName}.ts` as const;
       const t = diagnostics.total.filter((el) => el.file === filename);
 
       const d = diagnostics.current.filter((el) => el.file === filename);
       const c = entireCodes[filename]?.content ?? null;
 
-      return orchestrateRealizeCoder(ctx, op, p, c, t, d);
+      return orchestrateRealizeCoder(ctx, op, p, c, t, d).then((res) => {
+        if (res === FAILED) {
+        } else {
+          ctx.dispatch({
+            type: "realizeProgress",
+            filename: res.filename,
+            content: res.implementationCode,
+            completed: ++metadata.count,
+            created_at: new Date().toISOString(),
+            step: ctx.state().analyze?.step ?? 0,
+            total: metadata.total,
+          });
+        }
+        return res;
+      });
     },
   );
 
   if (result === FAILED) {
-    return { type: "failed", op, result } as const;
+    return { type: "failed", op: op, result } as const;
   }
 
-  return { type: "success", op, result: result } as const;
+  return { type: "success", op: op, result: result } as const;
 }
 
 function shouldProcessOperation(

package/src/orchestrate/test/orchestrateTest.ts

@@ -58,6 +58,7 @@ export const orchestrateTest =
       ctx,
       scenarioEvent.scenarios,
     );
+
     const corrects: AutoBeTestValidateEvent[] = await orchestrateTestCorrect(
       ctx,
       written,

package/src/orchestrate/test/orchestrateTestCorrect.ts

@@ -85,7 +85,7 @@ const predicate = async <Model extends ILlmSchema.Model>(
   event: AutoBeTestValidateEvent,
   life: number,
 ): Promise<AutoBeTestValidateEvent> => {
-  ctx.dispatch(event);
+  if (event.result.type === "failure") ctx.dispatch(event);
   return event.result.type === "failure"
     ? correct(ctx, content, event, life - 1)
     : event;

package/src/utils/backoffRetry.ts

@@ -1,7 +1,63 @@
+/*
+ * Random exponential backoff retry utility for handling rate limits
+ */
+export interface RetryOptions {
+  /** Maximum number of retry attempts (default: 5) */
+  maxRetries: number;
+  /** Base delay in milliseconds (default: 2000) */
+  baseDelay: number;
+  /** Maximum delay in milliseconds (default: 60_000) */
+  maxDelay: number;
+  /** Jitter factor for randomization (0-1, default: 0.3) */
+  jitter: number;
+  /** Function to determine if error should trigger retry (default: isRetryError) */
+  handleError: (error: any) => boolean;
+}
+
+/**
+ * @param fn Function to Apply the retry logic.
+ * @param maxRetries How many time to try. Max Retry is 5.
+ * @returns
+ */
+export async function randomBackoffRetry<T>(
+  fn: () => Promise<T>,
+  options: Partial<RetryOptions> = {},
+): Promise<T> {
+  const {
+    maxRetries = 5,
+    baseDelay = 4_000,
+    maxDelay = 60_000,
+    jitter = 0.8,
+    handleError = isRetryError,
+  } = options;
+
+  let lastError: unknown;
+
+  for (let attempt = 0; attempt < maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err;
+
+      if (attempt === maxRetries - 1) throw err;
+
+      if (!handleError(err)) throw err;
+
+      const tempDelay = Math.min(baseDelay * 2 ** attempt, maxDelay);
+      const delay = tempDelay * (1 + Math.random() * jitter);
+
+      await new Promise((res) => setTimeout(res, delay));
+    }
+  }
+
+  throw lastError;
+}
+
 export function randomBackoffStrategy(props: {
   count: number;
   error: unknown;
 }): number {
+  console.log("randomBackoffStrategy");
   const { count, error } = props;
   if (count > 5) {
     throw error;