@autobe/agent 0.23.1 → 0.24.0

package/src/factory/createAutoBeContext.ts

@@ -37,7 +37,7 @@ 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 { TimedConversation } from "../utils/TimedConversation";
 import { consentFunctionCall } from "./consentFunctionCall";
 import { getCriticalCompiler } from "./getCriticalCompiler";
 
@@ -57,7 +57,7 @@ export const createAutoBeContext = <Model extends ILlmSchema.Model>(props: {
     {
       retry: props.config.retry ?? AutoBeConfigConstant.RETRY,
       locale: props.config.locale ?? "en-US",
-      timeout: props.config.timeout ?? AutoBeConfigConstant.TIMEOUT,
+      timeout: props.config.timeout ?? null,
     };
   const critical: Semaphore = new Semaphore(2);
   return {
@@ -152,8 +152,8 @@ export const createAutoBeContext = <Model extends ILlmSchema.Model>(props: {
         if (closure) closure(agent);
 
         // DO CONVERSATE
-        const result: TimeoutConversation.IResult<Model> =
-          await TimeoutConversation.process({
+        const result: TimedConversation.IResult<Model> =
+          await TimedConversation.process({
             agent,
             timeout: config.timeout,
             message: next.message,
@@ -174,7 +174,7 @@ export const createAutoBeContext = <Model extends ILlmSchema.Model>(props: {
               type: "vendorTimeout",
               id: v7(),
               source: next.source,
-              timeout: config.timeout,
+              timeout: config.timeout!,
               retry: trial.timeout++,
               created_at: new Date().toISOString(),
             })

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

@@ -0,0 +1,60 @@
+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;
+}
+
+/** Transform date correction histories for AI conversation */
+export const transformCommonCorrectDateHistories = (
+  failures: IFailure[],
+): Array<
+  IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
+> => [
+  {
+    id: v7(),
+    created_at: new Date().toISOString(),
+    type: "systemMessage",
+    text: AutoBeSystemPromptConstant.REALIZE_DATE,
+  },
+  ...failures.map(
+    (f, i, array) =>
+      ({
+        id: v7(),
+        created_at: new Date().toISOString(),
+        type: "assistantMessage",
+        text: StringUtil.trim`
+          # ${i === array.length - 1 ? "Latest Date Type Failure" : "Previous Date Type Failure"}
+          
+          ## Generated TypeScript Code
+          \`\`\`typescript
+          ${f.script}
+          \`\`\`
+          
+          ## Date-Related Compile Errors
+          ${f.diagnostics
+            .map((d) => {
+              const location = d.file
+                ? `[${d.file}${d.start ? `:${d.start}` : ""}]`
+                : "[Unknown location]";
+              const code = d.code ? `TS${d.code}` : "";
+              const messageText = d.messageText || "Date type error";
+              return `- ${location} ${code}: ${messageText}`;
+            })
+            .join("\n")}
+          
+          ## Required Fixes:
+          - Replace all Date type declarations with string & tags.Format<"date-time">
+          - Wrap Date objects with toISOStringSafe(value)
+          - Check null/undefined BEFORE calling toISOStringSafe (it doesn't accept null)
+          - Remove Date variable declarations (const now = new Date() is forbidden)
+          - toISOStringSafe requires a parameter - it's not optional
+        `,
+      }) satisfies IAgenticaHistoryJson.IAssistantMessage,
+  ),
+];

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

@@ -0,0 +1,40 @@
+import typia from "typia";
+
+/** Application interface for Date type correction in generated code */
+export interface IAutoBeCommonCorrectDateApplication {
+  /**
+   * Rewrite the function to fix Date type issues
+   *
+   * @param props - Correction properties
+   */
+  rewrite(props: IAutoBeCommonCorrectDateApplication.IProps): void;
+
+  /** Reject the correction task if Date issues cannot be fixed */
+  reject(): void;
+}
+
+export namespace IAutoBeCommonCorrectDateApplication {
+  /** Properties for Date type correction */
+  export interface IProps {
+    /** The correction revision containing the fixed code */
+    revise: {
+      /** Optional: Analysis of Date type errors found */
+      analysis?: string & typia.tags.MaxLength<4000>;
+
+      /** Optional: Strategy for fixing Date issues */
+      strategy?: string & typia.tags.MaxLength<2000>;
+
+      /**
+       * Final corrected code with all Date type issues resolved
+       *
+       * Must follow these rules:
+       *
+       * - No ': Date' type declarations
+       * - All dates use 'string & tags.Format<"date-time">'
+       * - All Date objects wrapped with toISOStringSafe()
+       * - Null checks before toISOStringSafe()
+       */
+      final: string;
+    };
+  }
+}

package/src/orchestrate/realize/histories/transformRealizeWriteHistories.ts

@@ -114,7 +114,7 @@ export const transformRealizeWriteHistories = (props: {
       created_at: new Date().toISOString(),
       type: "systemMessage",
       text: AutoBeSystemPromptConstant.REALIZE_WRITE_ARTIFACT.replaceAll(
-        `{prisma_schemas}`,
+        `{prismaSchemas}`,
         JSON.stringify(props.state.prisma.schemas),
       )
         .replaceAll(

package/src/orchestrate/realize/orchestRateRealizeCorrectCasting.ts

@@ -131,8 +131,8 @@ const correct = async <Model extends ILlmSchema.Model>(
 
           Most casting errors are caused by type mismatches between Date types and 
           string & tags.Format<'date-time'>. To fix these:
-          - Use the pre-provided toISOStringSafe() function to convert Date to string
-          - Or use Date object's .toISOString() method
+          - Use ONLY the pre-provided toISOStringSafe() function to convert Date to string
+          - Do NOT use .toISOString() method directly (use toISOStringSafe instead)
           - Never use Date type directly in declarations or return values
 
           You don't need to explain me anything, but just fix or give it up 
@@ -225,7 +225,8 @@ const diagnose = (event: AutoBeRealizeValidateEvent): string[] => {
   const diagnostics = event.result.diagnostics;
   const locations = diagnostics
     .map((d) => d.file)
-    .filter((f): f is string => f !== null);
+    .filter((f): f is string => f !== null)
+    .filter((f) => f.startsWith("src/providers"));
 
   return Array.from(new Set(locations));
 };

package/src/orchestrate/realize/orchestrateRealize.ts

@@ -19,6 +19,7 @@ import { compileRealizeFiles } from "./internal/compileRealizeFiles";
 import { orchestrateRealizeCorrectCasting } from "./orchestRateRealizeCorrectCasting";
 import { orchestrateRealizeAuthorization } from "./orchestrateRealizeAuthorization";
 import { orchestrateRealizeCorrect } from "./orchestrateRealizeCorrect";
+import { orchestrateRealizeCorrectDate } from "./orchestrateRealizeCorrectDate";
 import { orchestrateRealizeWrite } from "./orchestrateRealizeWrite";
 import { IAutoBeRealizeFunctionFailure } from "./structures/IAutoBeRealizeFunctionFailure";
 import { IAutoBeRealizeScenarioResult } from "./structures/IAutoBeRealizeScenarioResult";
@@ -110,34 +111,39 @@ export const orchestrateRealize =
         authorizations,
         functions,
         reviewProgress,
+        parseInt((ctx.retry / 2).toString()),
       );
 
-    console.log("converted end");
-    console.log("converted end");
-    console.log("converted end");
-    console.log("converted end");
-    console.log("converted end");
-    console.log("converted end");
-    const corrected: AutoBeRealizeFunction[] = await orchestrateRealizeCorrect(
-      ctx,
-      scenarios,
-      authorizations,
-      converted,
-      [] satisfies IAutoBeRealizeFunctionFailure[],
-      reviewProgress,
-    );
+    const correctedDate: AutoBeRealizeFunction[] =
+      await orchestrateRealizeCorrectDate(
+        ctx,
+        authorizations,
+        converted,
+        reviewProgress,
+        parseInt((ctx.retry / 2).toString()),
+      );
+
+    const totalCorrected: AutoBeRealizeFunction[] =
+      await orchestrateRealizeCorrect(
+        ctx,
+        scenarios,
+        authorizations,
+        correctedDate,
+        [] satisfies IAutoBeRealizeFunctionFailure[],
+        reviewProgress,
+      );
 
     const compiler: IAutoBeCompiler = await ctx.compiler();
     const controllers: Record<string, string> =
       await compiler.realize.controller({
         document: ctx.state().interface!.document,
-        functions: corrected,
+        functions: totalCorrected,
         authorizations,
       });
 
     const { result } = await compileRealizeFiles(ctx, {
       authorizations,
-      functions: corrected,
+      functions: totalCorrected,
     });
 
     return ctx.dispatch({

package/src/orchestrate/realize/orchestrateRealizeCorrect.ts

@@ -18,6 +18,7 @@ import { compileRealizeFiles } from "./internal/compileRealizeFiles";
 import { IAutoBeRealizeCorrectApplication } from "./structures/IAutoBeRealizeCorrectApplication";
 import { IAutoBeRealizeFunctionFailure } from "./structures/IAutoBeRealizeFunctionFailure";
 import { IAutoBeRealizeScenarioResult } from "./structures/IAutoBeRealizeScenarioResult";
+import { filterDiagnostics } from "./utils/filterDiagnostics";
 import { getRealizeWriteDto } from "./utils/getRealizeWriteDto";
 import { replaceImportStatements } from "./utils/replaceImportStatements";
 
@@ -42,7 +43,10 @@ export async function orchestrateRealizeCorrect<Model extends ILlmSchema.Model>(
   const diagnostics = event.result.diagnostics;
   const locations: string[] = Array.from(
     new Set(
-      diagnostics.map((d) => d.file).filter((f): f is string => f !== null),
+      diagnostics
+        .map((d) => d.file)
+        .filter((f): f is string => f !== null)
+        .filter((f) => f.startsWith("src/providers")),
     ),
   );
 
@@ -53,9 +57,15 @@ export async function orchestrateRealizeCorrect<Model extends ILlmSchema.Model>(
   diagnostics.forEach((diagnostic) => {
     const location: string | null = diagnostic.file;
     if (location === null) return;
+    if (!location.startsWith("src/providers")) return;
 
     if (!diagnosticsByFile[location]) {
-      const func = functions.find((f) => f.location === location)!;
+      const func = functions.find((f) => f.location === location);
+
+      if (!func) {
+        return;
+      }
+
       const failure: IAutoBeRealizeFunctionFailure = {
         function: func,
         diagnostics: [],
@@ -65,13 +75,21 @@ export async function orchestrateRealizeCorrect<Model extends ILlmSchema.Model>(
     diagnosticsByFile[location].diagnostics.push(diagnostic);
   });
 
-  await correct(
+  const newFailures: IAutoBeRealizeFunctionFailure[] = [
+    ...failures,
+    ...Object.values(diagnosticsByFile),
+  ];
+
+  const corrected: AutoBeRealizeFunction[] = await correct(
     ctx,
     locations,
     scenarios,
     authorizations,
     functions,
-    [...failures, ...Object.values(diagnosticsByFile)],
+    filterDiagnostics(
+      newFailures,
+      functions.map((fn) => fn.location),
+    ),
     progress,
   );
 
@@ -79,8 +97,11 @@ export async function orchestrateRealizeCorrect<Model extends ILlmSchema.Model>(
     ctx,
     scenarios,
     authorizations,
-    functions,
-    [...failures, ...Object.values(diagnosticsByFile)],
+    corrected,
+    filterDiagnostics(
+      newFailures,
+      corrected.map((c) => c.location),
+    ),
     progress,
     life - 1,
   );
@@ -95,25 +116,30 @@ async function correct<Model extends ILlmSchema.Model>(
   failures: IAutoBeRealizeFunctionFailure[],
   progress: AutoBeProgressEventBase,
 ): Promise<AutoBeRealizeFunction[]> {
-  return executeCachedBatch(
+  const result: AutoBeRealizeFunction[] = await executeCachedBatch(
     locations.map((location) => async (): Promise<AutoBeRealizeFunction> => {
       const scenario = scenarios.find((el) => el.location === location);
-      const func = functions.find((el) => el.location === location)!;
-      const ReailzeFunctionFailures: IAutoBeRealizeFunctionFailure[] =
-        failures.filter((f) => f.function.location === location);
+      const func = functions.find((el) => el.location === location);
+
+      if (!func) {
+        throw new Error("No function found for location: " + location);
+      }
 
-      if (ReailzeFunctionFailures.length && scenario) {
+      const RealizeFunctionFailures: IAutoBeRealizeFunctionFailure[] =
+        failures.filter((f) => f.function?.location === location);
+
+      if (RealizeFunctionFailures.length && scenario) {
         try {
           const correctEvent = await step(ctx, {
             totalAuthorizations: authorizations,
             authorization: scenario.decoratorEvent ?? null,
             scenario,
             function: func,
-            failures: ReailzeFunctionFailures,
+            failures: RealizeFunctionFailures,
             progress: progress,
           });
 
-          func.content = correctEvent.content;
+          return { ...func, content: correctEvent.content };
         } catch (err) {
           return func;
         }
@@ -122,6 +148,8 @@ async function correct<Model extends ILlmSchema.Model>(
       return func;
     }),
   );
+
+  return result;
 }
 
 async function step<Model extends ILlmSchema.Model>(
@@ -168,9 +196,9 @@ async function step<Model extends ILlmSchema.Model>(
   if (pointer.value === null)
     throw new Error("Failed to correct implementation code.");
 
-  pointer.value.revise.implementationCode = await replaceImportStatements(ctx, {
+  pointer.value.revise.final = await replaceImportStatements(ctx, {
     operation: props.scenario.operation,
-    code: pointer.value.revise.implementationCode,
+    code: pointer.value.revise.final,
     decoratorType: props.authorization?.payload.name,
   });
 
@@ -178,7 +206,7 @@ async function step<Model extends ILlmSchema.Model>(
     type: "realizeCorrect",
     id: v7(),
     location: props.scenario.location,
-    content: pointer.value.revise.implementationCode,
+    content: pointer.value.revise.final,
     tokenUsage,
     completed: ++props.progress.completed,
     total: props.progress.total,