@autobe/agent 0.24.2 → 0.25.0

package/src/orchestrate/test/orchestrateTest.ts

@@ -38,7 +38,7 @@ export const orchestrateTest =
       type: "testStart",
       id: v7(),
       created_at: start.toISOString(),
-      reason: props.reason,
+      reason: props.instruction,
       step: ctx.state().analyze?.step ?? 0,
     });
 
@@ -57,31 +57,37 @@ export const orchestrateTest =
       });
 
     // PLAN
-    const scenarios: AutoBeTestScenario[] = await orchestrateTestScenario(ctx);
+    const scenarios: AutoBeTestScenario[] = await orchestrateTestScenario(
+      ctx,
+      props.instruction,
+    );
     if (scenarios.length === 0)
       throw new Error("No scenarios generated. Please check the logs.");
 
     // TEST CODE
-    const written: IAutoBeTestWriteResult[] = await orchestrateTestWrite(
-      ctx,
+    const written: IAutoBeTestWriteResult[] = await orchestrateTestWrite(ctx, {
+      instruction: props.instruction,
       scenarios,
-    );
+    });
     if (written.length === 0)
       throw new Error("No test code written. Please check the logs.");
 
     const corrects: AutoBeTestValidateEvent[] = await orchestrateTestCorrect(
       ctx,
-      written.map((w) => ({
-        scenario: w.scenario,
-        artifacts: w.artifacts,
-        location: w.event.location,
-        script: w.event.final ?? w.event.draft,
-      })),
+      {
+        instruction: props.instruction,
+        functions: written.map((w) => ({
+          scenario: w.scenario,
+          artifacts: w.artifacts,
+          location: w.event.location,
+          script: w.event.final ?? w.event.draft,
+        })),
+      },
     );
 
     // DO COMPILE
     const compiler: IAutoBeCompiler = await ctx.compiler();
-    const compiled: IAutoBeTypeScriptCompileResult =
+    const compileResult: IAutoBeTypeScriptCompileResult =
       await compiler.typescript.compile({
         files: Object.fromEntries([
           ...Object.entries(
@@ -97,7 +103,7 @@ export const orchestrateTest =
       id: v7(),
       created_at: new Date().toISOString(),
       files: corrects.map((s) => s.file),
-      compiled,
+      compiled: compileResult,
       step: ctx.state().interface?.step ?? 0,
       elapsed: new Date().getTime() - start.getTime(),
     });

package/src/orchestrate/test/orchestrateTestCorrect.ts

@@ -25,11 +25,14 @@ import { IAutoBeTestFunctionFailure } from "./structures/IAutoBeTestFunctionFail
 
 export const orchestrateTestCorrect = async <Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
-  writeResults: IAutoBeTestFunction[],
+  props: {
+    instruction: string;
+    functions: IAutoBeTestFunction[];
+  },
 ): Promise<AutoBeTestValidateEvent[]> => {
   const result: Array<AutoBeTestValidateEvent | null> =
     await executeCachedBatch(
-      writeResults.map((w) => async (promptCacheKey) => {
+      props.functions.map((w) => async (promptCacheKey) => {
         try {
           const compile = (script: string) =>
             compileTestFile(ctx, {
@@ -68,10 +71,13 @@ export const orchestrateTestCorrect = async <Model extends ILlmSchema.Model>(
             );
           return await predicate(
             ctx,
-            transformTestValidateEvent(y, w.artifacts),
-            [],
-            y,
-            promptCacheKey,
+            {
+              function: transformTestValidateEvent(y, w.artifacts),
+              failures: [],
+              validate: y,
+              promptCacheKey,
+              instruction: props.instruction,
+            },
             ctx.retry,
           );
         } catch {
@@ -110,44 +116,54 @@ const compileTestFile = async <Model extends ILlmSchema.Model>(
 
 const predicate = async <Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
-  content: IAutoBeTestFunction,
-  failures: IAutoBeTestFunctionFailure[],
-  event: AutoBeTestValidateEvent,
-  promptCacheKey: string,
+  props: {
+    function: IAutoBeTestFunction;
+    failures: IAutoBeTestFunctionFailure[];
+    validate: AutoBeTestValidateEvent;
+    promptCacheKey: string;
+    instruction: string;
+  },
   life: number,
 ): Promise<AutoBeTestValidateEvent> => {
-  if (event.result.type === "failure") ctx.dispatch(event);
-  return event.result.type === "failure"
-    ? await correct(ctx, content, failures, event, promptCacheKey, life - 1)
-    : event;
+  if (props.validate.result.type === "failure") ctx.dispatch(props.validate);
+  return props.validate.result.type === "failure"
+    ? await correct(ctx, props, life - 1)
+    : props.validate;
 };
 
 const correct = async <Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
-  content: IAutoBeTestFunction,
-  failures: IAutoBeTestFunctionFailure[],
-  validate: AutoBeTestValidateEvent,
-  promptCacheKey: string,
+  props: {
+    function: IAutoBeTestFunction;
+    failures: IAutoBeTestFunctionFailure[];
+    validate: AutoBeTestValidateEvent;
+    promptCacheKey: string;
+    instruction: string;
+  },
   life: number,
 ): Promise<AutoBeTestValidateEvent> => {
-  if (validate.result.type !== "failure") return validate;
-  else if (life < 0) return validate;
+  if (props.validate.result.type !== "failure") return props.validate;
+  else if (life < 0) return props.validate;
 
   const pointer: IPointer<IAutoBeTestCorrectApplication.IProps | null> = {
     value: null,
   };
   const { tokenUsage } = await ctx.conversate({
     source: "testCorrect",
-    histories: await transformTestCorrectHistories(ctx, content, [
-      ...failures,
-      {
-        function: content,
-        failure: validate.result,
-      },
-    ]),
+    histories: await transformTestCorrectHistories(ctx, {
+      instruction: props.instruction,
+      function: props.function,
+      failures: [
+        ...props.failures,
+        {
+          function: props.function,
+          failure: props.validate.result,
+        },
+      ],
+    }),
     controller: createController({
       model: ctx.model,
-      failure: validate.result,
+      failure: props.validate.result,
       build: (next) => {
         pointer.value = next;
       },
@@ -159,18 +175,18 @@ const correct = async <Model extends ILlmSchema.Model>(
       You don't need to explain me anything, but just fix it immediately
       without any hesitation, explanation, and questions.
     `,
-    promptCacheKey,
+    promptCacheKey: props.promptCacheKey,
   });
   if (pointer.value === null) throw new Error("Failed to correct test code.");
 
   pointer.value.revise.final = await completeTestCode(
     ctx,
-    content.artifacts,
+    props.function.artifacts,
     pointer.value.revise.final,
   );
   pointer.value.draft = await completeTestCode(
     ctx,
-    content.artifacts,
+    props.function.artifacts,
     pointer.value.draft,
   );
 
@@ -178,8 +194,8 @@ const correct = async <Model extends ILlmSchema.Model>(
     type: "testCorrect",
     id: v7(),
     created_at: new Date().toISOString(),
-    file: validate.file,
-    result: validate.result,
+    file: props.validate.file,
+    result: props.validate.result,
     tokenUsage,
     step: ctx.state().analyze?.step ?? 0,
     think: pointer.value.think,
@@ -187,26 +203,29 @@ const correct = async <Model extends ILlmSchema.Model>(
     review: pointer.value.revise?.review,
     final: pointer.value.revise?.final,
   } satisfies AutoBeTestCorrectEvent);
-  const newContent: IAutoBeTestFunction = {
-    ...content,
+  const newFunction: IAutoBeTestFunction = {
+    ...props.function,
     script: pointer.value.revise?.final ?? pointer.value.draft,
   };
   const newValidate: AutoBeTestValidateEvent = await compileTestFile(
     ctx,
-    newContent,
+    newFunction,
   );
   return predicate(
     ctx,
-    newContent,
-    [
-      ...failures,
-      {
-        function: content,
-        failure: validate.result,
-      },
-    ],
-    newValidate,
-    promptCacheKey,
+    {
+      function: newFunction,
+      failures: [
+        ...props.failures,
+        {
+          function: props.function,
+          failure: props.validate.result,
+        },
+      ],
+      validate: newValidate,
+      promptCacheKey: props.promptCacheKey,
+      instruction: props.instruction,
+    },
     life,
   );
 };

package/src/orchestrate/test/orchestrateTestScenario.ts

@@ -23,6 +23,7 @@ import { IAutoBeTestScenarioAuthorizationRole } from "./structures/IAutoBeTestSc
 
 export async function orchestrateTestScenario<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
+  instruction: string,
 ): Promise<AutoBeTestScenario[]> {
   const document: AutoBeOpenApi.IDocument | undefined =
     ctx.state().interface?.document;
@@ -87,6 +88,7 @@ export async function orchestrateTestScenario<Model extends ILlmSchema.Model>(
             progress,
             reviewProgress,
             promptCacheKey,
+            instruction,
           })),
         );
       }),
@@ -129,6 +131,7 @@ const divideAndConquer = async <Model extends ILlmSchema.Model>(
     progress: AutoBeProgressEventBase;
     reviewProgress: AutoBeProgressEventBase;
     promptCacheKey: string;
+    instruction: string;
   },
 ): Promise<IAutoBeTestScenarioApplication.IScenarioGroup[]> => {
   const pointer: IPointer<IAutoBeTestScenarioApplication.IScenarioGroup[]> = {
@@ -140,12 +143,13 @@ const divideAndConquer = async <Model extends ILlmSchema.Model>(
   try {
     const { tokenUsage } = await ctx.conversate({
       source: "testScenarios",
-      histories: transformTestScenarioHistories(
-        ctx.state(),
-        props.document,
-        props.include,
-        props.exclude,
-      ),
+      histories: transformTestScenarioHistories({
+        state: ctx.state(),
+        document: props.document,
+        include: props.include,
+        exclude: props.exclude,
+        instruction: props.instruction,
+      }),
       controller: createController({
         model: ctx.model,
         endpointNotFound: props.endpointNotFound,
@@ -193,11 +197,11 @@ const divideAndConquer = async <Model extends ILlmSchema.Model>(
       step: ctx.state().interface?.step ?? 0,
       created_at: new Date().toISOString(),
     });
-    return await orchestrateTestScenarioReview(
-      ctx,
-      pointer.value,
-      props.reviewProgress,
-    );
+    return await orchestrateTestScenarioReview(ctx, {
+      instruction: props.instruction,
+      groups: pointer.value,
+      progress: props.reviewProgress,
+    });
   } catch {
     return [];
   }

package/src/orchestrate/test/orchestrateTestScenarioReview.ts

@@ -16,21 +16,26 @@ export async function orchestrateTestScenarioReview<
   Model extends ILlmSchema.Model,
 >(
   ctx: AutoBeContext<Model>,
-  groups: IAutoBeTestScenarioApplication.IScenarioGroup[],
-  progress: AutoBeProgressEventBase,
+  props: {
+    instruction: string;
+    groups: IAutoBeTestScenarioApplication.IScenarioGroup[];
+    progress: AutoBeProgressEventBase;
+  },
 ): Promise<IAutoBeTestScenarioApplication.IScenarioGroup[]> {
   const res: IAutoBeTestScenarioApplication.IScenarioGroup[] = await review(
     ctx,
-    groups,
-    progress,
+    props,
   );
   return res;
 }
 
 async function review<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
-  groups: IAutoBeTestScenarioApplication.IScenarioGroup[],
-  progress: AutoBeProgressEventBase,
+  props: {
+    instruction: string;
+    groups: IAutoBeTestScenarioApplication.IScenarioGroup[];
+    progress: AutoBeProgressEventBase;
+  },
 ): Promise<IAutoBeTestScenarioApplication.IScenarioGroup[]> {
   try {
     const pointer: IPointer<IAutoBeTestScenarioReviewApplication.IProps | null> =
@@ -42,9 +47,13 @@ async function review<Model extends ILlmSchema.Model>(
       controller: createController({
         model: ctx.model,
         pointer,
-        originalGroups: groups,
+        originalGroups: props.groups,
+      }),
+      histories: transformTestScenarioReviewHistories({
+        state: ctx.state(),
+        groups: props.groups,
+        instruction: props.instruction,
       }),
-      histories: transformTestScenarioReviewHistories(ctx, groups),
       enforceFunctionCall: true,
       message: "Review the Test Scenario.",
     });
@@ -53,17 +62,17 @@ async function review<Model extends ILlmSchema.Model>(
       throw new Error("Failed to get review result.");
     }
 
-    progress.total = Math.max(
-      progress.total,
-      (progress.completed += pointer.value.scenarioGroups.length),
+    props.progress.total = Math.max(
+      props.progress.total,
+      (props.progress.completed += pointer.value.scenarioGroups.length),
     );
 
     ctx.dispatch({
       type: "testScenariosReview",
       id: v7(),
       tokenUsage,
-      total: progress.total,
-      completed: progress.completed,
+      total: props.progress.total,
+      completed: props.progress.completed,
       scenarios: pointer.value.scenarioGroups
         .map((group) => {
           return group.scenarios.map((s) => {
@@ -77,10 +86,14 @@ async function review<Model extends ILlmSchema.Model>(
       step: ctx.state().interface?.step ?? 0,
       created_at: new Date().toISOString(),
     });
-    return pointer.value.scenarioGroups;
+    // @todo michael: need to investigate scenario removal more gracefully
+    return pointer.value.pass
+      ? // || pointer.value.scenarioGroups.length < props.groups.length
+        props.groups
+      : pointer.value.scenarioGroups;
   } catch {
-    progress.completed += groups.length;
-    return groups;
+    props.progress.completed += props.groups.length;
+    return props.groups;
   }
 }
 

package/src/orchestrate/test/orchestrateTestWrite.ts

@@ -22,10 +22,13 @@ import { IAutoBeTestWriteResult } from "./structures/IAutoBeTestWriteResult";
 
 export async function orchestrateTestWrite<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
-  scenarios: AutoBeTestScenario[],
+  props: {
+    instruction: string;
+    scenarios: AutoBeTestScenario[];
+  },
 ): Promise<IAutoBeTestWriteResult[]> {
   const progress: AutoBeProgressEventBase = {
-    total: scenarios.length,
+    total: props.scenarios.length,
     completed: 0,
   };
   const result: Array<IAutoBeTestWriteResult | null> = await executeCachedBatch(
@@ -34,7 +37,7 @@ export async function orchestrateTestWrite<Model extends ILlmSchema.Model>(
      * individual test code implementations. Each scenario is processed to
      * generate corresponding test code and progress events.
      */
-    scenarios.map((scenario) => async (promptCacheKey) => {
+    props.scenarios.map((scenario) => async (promptCacheKey) => {
       try {
         const artifacts: IAutoBeTestScenarioArtifacts =
           await getTestScenarioArtifacts(ctx, scenario);
@@ -43,6 +46,7 @@ export async function orchestrateTestWrite<Model extends ILlmSchema.Model>(
           artifacts,
           progress,
           promptCacheKey,
+          instruction: props.instruction,
         });
         ctx.dispatch(event);
         return {
@@ -65,6 +69,7 @@ async function process<Model extends ILlmSchema.Model>(
     artifacts: IAutoBeTestScenarioArtifacts;
     progress: AutoBeProgressEventBase;
     promptCacheKey: string;
+    instruction: string;
   },
 ): Promise<AutoBeTestWriteEvent> {
   const { scenario, artifacts, progress, promptCacheKey } = props;
@@ -73,7 +78,11 @@ async function process<Model extends ILlmSchema.Model>(
   };
   const { tokenUsage } = await ctx.conversate({
     source: "testWrite",
-    histories: await transformTestWriteHistories(ctx, scenario, artifacts),
+    histories: await transformTestWriteHistories(ctx, {
+      scenario,
+      artifacts,
+      instruction: props.instruction,
+    }),
     controller: createController({
       model: ctx.model,
       build: (next) => {

package/lib/orchestrate/common/histories/transformCommonCorrectDateHistories.js

@@ -1,48 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformCommonCorrectDateHistories = void 0;
-const utils_1 = require("@autobe/utils");
-const uuid_1 = require("uuid");
-/** Transform date correction histories for AI conversation */
-const transformCommonCorrectDateHistories = (failures) => [
-    {
-        id: (0, uuid_1.v7)(),
-        created_at: new Date().toISOString(),
-        type: "systemMessage",
-        text: "<!--\nfilename: REALIZE_DATE.md\n-->\n# \uD83D\uDCC5 Date Type Handling Guide for Realize Agent\n\n## \uD83D\uDEA8 CRITICAL: Date Type is ABSOLUTELY FORBIDDEN in TypeScript Declarations\n\nThis document provides comprehensive guidelines for handling date-related types in the Realize Agent system. Violations of these rules will cause compilation failures.\n\n## \uD83D\uDD34 The Golden Rule: NEVER Use Native Date Type\n\n### \u274C ABSOLUTELY FORBIDDEN\n```typescript\n// NEVER declare variables with Date type\nconst now: Date = new Date();                              // \u274C FORBIDDEN\nconst processDate = (date: Date) => { ... };               // \u274C FORBIDDEN\nfunction getDate(): Date { ... }                           // \u274C FORBIDDEN\ninterface IUser { created_at: Date; }                      // \u274C FORBIDDEN\ntype TimeStamp = Date;                                     // \u274C FORBIDDEN\n```\n\n### \u2705 REQUIRED: Always Use String with Tags\n```typescript\n// ALWAYS use string with tags.Format<'date-time'>\nconst now: string & tags.Format<'date-time'> = toISOStringSafe(new Date());\nconst processDate = (date: string & tags.Format<'date-time'>) => { ... };\nfunction getDate(): string & tags.Format<'date-time'> { ... }\ninterface IUser { created_at: string & tags.Format<'date-time'>; }\ntype TimeStamp = string & tags.Format<'date-time'>;\n```\n\n## \uD83D\uDEE0\uFE0F The toISOStringSafe() Function\n\n### Function Signature\n```typescript\nfunction toISOStringSafe(\n  value: Date | (string & tags.Format<\"date-time\">)\n): string & tags.Format<\"date-time\">\n```\n\n### Purpose\n`toISOStringSafe()` is the ONLY approved method for converting Date objects or date strings to ISO strings with proper type branding.\n\n### \u26A0\uFE0F CRITICAL: Parameter Requirements\n\n**toISOStringSafe REQUIRES a non-null parameter!**\n- The function accepts `Date` or ISO string format\n- It does NOT accept `null` or `undefined`\n- Always check for null/undefined BEFORE calling\n\n```typescript\n// \u274C WRONG: Function doesn't accept null\ntoISOStringSafe(nullableValue)                             // Type error if nullable!\n\n// \u2705 CORRECT: Check null first, then call\nvalue ? toISOStringSafe(value) : null                      // Safe null handling\n```\n\n### Common Usage Patterns\n\n#### 1. Creating New Timestamps\n```typescript\n// \u2705 For new timestamps\nconst created_at = toISOStringSafe(new Date());\nconst updated_at = toISOStringSafe(new Date());\n\n// \u2705 Converting existing date strings\nconst formatted_date = toISOStringSafe(dateString);\n```\n\n#### 2. Converting Prisma DateTime Fields\n```typescript\n// \u2705 Converting from Prisma (which returns Date objects)\nreturn {\n  created_at: toISOStringSafe(created.created_at),\n  updated_at: toISOStringSafe(created.updated_at),\n  expires_at: created.expires_at ? toISOStringSafe(created.expires_at) : null,\n};\n```\n\n#### 3. Processing API Input Dates\n```typescript\n// \u2705 Converting date strings from API input\nawait MyGlobal.prisma.posts.create({\n  data: {\n    title: body.title,\n    content: body.content,\n    published_at: body.published_at ? toISOStringSafe(body.published_at) : null,\n    scheduled_at: body.scheduled_at ? toISOStringSafe(body.scheduled_at) : null,\n  },\n});\n```\n\n## \uD83D\uDCCA Date Field Patterns in Different Contexts\n\n### 1. Prisma Operations\n\n#### CREATE Operations\n```typescript\nawait MyGlobal.prisma.articles.create({\n  data: {\n    id: v4() as string & tags.Format<'uuid'>,\n    title: body.title,\n    content: body.content,\n    // Required date fields\n    created_at: toISOStringSafe(new Date()),\n    updated_at: toISOStringSafe(new Date()),\n    // Optional/nullable date fields\n    published_at: body.published_at ? toISOStringSafe(body.published_at) : null,\n    deleted_at: null,  // If soft delete field exists\n  },\n});\n```\n\n#### UPDATE Operations\n```typescript\nawait MyGlobal.prisma.articles.update({\n  where: { id: parameters.id },\n  data: {\n    title: body.title,\n    content: body.content,\n    // Always update the updated_at field\n    updated_at: toISOStringSafe(new Date()),\n    // Conditional date updates\n    ...(body.published_at !== undefined && {\n      published_at: body.published_at ? toISOStringSafe(body.published_at) : null\n    }),\n  },\n});\n```\n\n#### WHERE Clauses with Date Ranges\n```typescript\nawait MyGlobal.prisma.events.findMany({\n  where: {\n    // Date range queries\n    created_at: {\n      gte: body.start_date ? toISOStringSafe(body.start_date) : undefined,\n      lte: body.end_date ? toISOStringSafe(body.end_date) : undefined,\n    },\n    // Specific date comparisons\n    expires_at: {\n      gt: toISOStringSafe(new Date()),  // Events not yet expired\n    },\n  },\n});\n```\n\n### 2. Return Object Transformations\n\n#### From Prisma to API Response\n```typescript\n// Prisma returns Date objects, API expects ISO strings\nconst users = await MyGlobal.prisma.users.findMany();\n\nreturn users.map(user => ({\n  id: user.id,\n  name: user.name,\n  email: user.email,\n  // Convert all Date fields to ISO strings\n  created_at: toISOStringSafe(user.created_at),\n  updated_at: toISOStringSafe(user.updated_at),\n  last_login_at: user.last_login_at ? toISOStringSafe(user.last_login_at) : null,\n  email_verified_at: user.email_verified_at ? toISOStringSafe(user.email_verified_at) : null,\n}));\n```\n\n### 3. Complex Date Operations\n\n#### Soft Delete Implementation\n```typescript\n// If schema has deleted_at field (always check first!)\nawait MyGlobal.prisma.posts.update({\n  where: { id: parameters.id },\n  data: {\n    deleted_at: toISOStringSafe(new Date()),  // Mark as deleted\n    updated_at: toISOStringSafe(new Date()),\n  },\n});\n\n// Querying non-deleted items\nawait MyGlobal.prisma.posts.findMany({\n  where: {\n    deleted_at: null,  // Only get non-deleted posts\n  },\n});\n```\n\n#### Date Calculations\n```typescript\n// Calculate expiry date (30 days from now)\nconst now = new Date();\nconst expiryDate = new Date(now.getTime() + 30 * 24 * 60 * 60 * 1000);\n\nawait MyGlobal.prisma.subscriptions.create({\n  data: {\n    user_id: user.id,\n    started_at: toISOStringSafe(now),\n    expires_at: toISOStringSafe(expiryDate),\n  },\n});\n```\n\n## \uD83D\uDEAB Common Date Type Errors and Solutions\n\n### Error: \"Type 'Date' is not assignable to type 'string & tags.Format<'date-time'>'\"\n\n**Cause**: Trying to assign a Date object directly without conversion\n\n```typescript\n// \u274C WRONG\nreturn {\n  created_at: new Date(),  // ERROR!\n};\n\n// \u2705 CORRECT\nreturn {\n  created_at: toISOStringSafe(new Date()),\n};\n```\n\n### Error: \"Argument of type 'null' is not assignable to parameter\"\n\n**Cause**: Trying to pass null or undefined to toISOStringSafe\n\n```typescript\n// \u274C WRONG\nconst date = toISOStringSafe(nullableDate);  // Type error if nullable!\n\n// \u2705 CORRECT\nconst date = nullableDate ? toISOStringSafe(nullableDate) : null;\n```\n\n### Error: \"Type 'string | null' is not assignable to type 'string & tags.Format<'date-time'>'\"\n\n**Cause**: Nullable date field being assigned to required date field\n\n```typescript\n// \u274C WRONG (if API expects non-nullable)\nreturn {\n  created_at: user.created_at ? toISOStringSafe(user.created_at) : null,  // ERROR!\n};\n\n// \u2705 CORRECT (provide default for required fields)\nreturn {\n  created_at: user.created_at \n    ? toISOStringSafe(user.created_at) \n    : toISOStringSafe(new Date()),  // Default to current time\n};\n```\n\n## \uD83D\uDCCB Date Type Checklist\n\nBefore implementing any date-related functionality, verify:\n\n1. \u2705 **NO Date type declarations** - Search for `: Date` in your code\n2. \u2705 **All Date objects wrapped in toISOStringSafe()** - Never use .toISOString() directly\n3. \u2705 **Null checks before toISOStringSafe()** - Function cannot handle null\n4. \u2705 **Proper type annotations** - Use `string & tags.Format<'date-time'>`\n5. \u2705 **Schema verification** - Check if date fields actually exist in Prisma schema\n6. \u2705 **API contract alignment** - Verify if fields are nullable or required in DTOs\n\n## \uD83C\uDFAF Quick Reference\n\n### DO \u2705\n- `toISOStringSafe(new Date())`\n- `toISOStringSafe(dateString)` for existing strings\n- `value ? toISOStringSafe(value) : null` for nullable values\n- `string & tags.Format<'date-time'>` for type declarations\n- Check null/undefined BEFORE calling toISOStringSafe\n- Check Prisma schema for date field existence\n\n### DON'T \u274C\n- `const date: Date = new Date()` - storing Date in variables\n- `new Date().toISOString()` - use toISOStringSafe instead\n- `toISOStringSafe(nullableValue)` - function doesn't accept null\n- `toISOStringSafe()` - function requires a parameter\n- Assume date fields exist (like deleted_at)\n- Use Date type in function signatures\n\n## \uD83D\uDD0D Exception: new Date() Usage\n\nThe ONLY acceptable use of `new Date()` is as an immediate argument to `toISOStringSafe()`:\n\n```typescript\n// \u2705 ONLY ALLOWED PATTERN\nconst timestamp = toISOStringSafe(new Date());\n\n// \u274C NEVER STORE Date IN VARIABLE\nconst now = new Date();  // FORBIDDEN!\nconst timestamp = toISOStringSafe(now);  // VIOLATION!\n```\n\n## \uD83D\uDCDD Summary\n\nThe Date type handling in Realize Agent follows a strict pattern:\n1. **Never** declare Date types in TypeScript\n2. **Always** use `string & tags.Format<'date-time'>` for type declarations\n3. **Always** use `toISOStringSafe()` for Date/string to ISO conversions\n4. **Always** check null/undefined before calling `toISOStringSafe()` - it doesn't accept null\n5. **Always** pass a parameter to `toISOStringSafe()` - it's not optional\n6. **Always** verify schema before using date fields\n\nFollowing these rules ensures type safety, prevents runtime errors, and maintains consistency across the entire codebase." /* AutoBeSystemPromptConstant.REALIZE_DATE */,
-    },
-    ...failures.map((f, i, array) => ({
-        id: (0, uuid_1.v7)(),
-        created_at: new Date().toISOString(),
-        type: "assistantMessage",
-        text: utils_1.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
-        `,
-    })),
-];
-exports.transformCommonCorrectDateHistories = transformCommonCorrectDateHistories;
-//# sourceMappingURL=transformCommonCorrectDateHistories.js.map

package/lib/orchestrate/common/histories/transformCommonCorrectDateHistories.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"transformCommonCorrectDateHistories.js","sourceRoot":"","sources":["../../../../src/orchestrate/common/histories/transformCommonCorrectDateHistories.ts"],"names":[],"mappings":";;;AAEA,yCAA2C;AAC3C,+BAA0B;AAS1B,8DAA8D;AACvD,MAAM,mCAAmC,GAAG,CACjD,QAAoB,EAGpB,EAAE,CAAC;IACH;QACE,EAAE,EAAE,IAAA,SAAE,GAAE;QACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;QACpC,IAAI,EAAE,eAAe;QACrB,IAAI,+wTAAyC;KAC9C;IACD,GAAG,QAAQ,CAAC,GAAG,CACb,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,EAAE,CACd,CAAC;QACC,EAAE,EAAE,IAAA,SAAE,GAAE;QACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;QACpC,IAAI,EAAE,kBAAkB;QACxB,IAAI,EAAE,kBAAU,CAAC,IAAI,CAAA;cACf,CAAC,KAAK,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,0BAA0B,CAAC,CAAC,CAAC,4BAA4B;;;;YAIpF,CAAC,CAAC,MAAM;;;;YAIR,CAAC,CAAC,WAAW;aACZ,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE;YACT,MAAM,QAAQ,GAAG,CAAC,CAAC,IAAI;gBACrB,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,GAAG;gBAC9C,CAAC,CAAC,oBAAoB,CAAC;YACzB,MAAM,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YACzC,MAAM,WAAW,GAAG,CAAC,CAAC,WAAW,IAAI,iBAAiB,CAAC;YACvD,OAAO,KAAK,QAAQ,IAAI,IAAI,KAAK,WAAW,EAAE,CAAC;QACjD,CAAC,CAAC;aACD,IAAI,CAAC,IAAI,CAAC;;;;;;;;SAQd;KACF,CAAkD,CACtD;CACF,CAAC;AA9CW,QAAA,mCAAmC,uCA8C9C"}

package/lib/orchestrate/common/structures/IAutoBeCommonCorrectDateApplication.d.ts

@@ -1,35 +0,0 @@
-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 declare namespace IAutoBeCommonCorrectDateApplication {
-    /** Properties for Date type correction */
-    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/lib/orchestrate/common/structures/IAutoBeCommonCorrectDateApplication.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=IAutoBeCommonCorrectDateApplication.js.map

package/lib/orchestrate/common/structures/IAutoBeCommonCorrectDateApplication.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"IAutoBeCommonCorrectDateApplication.js","sourceRoot":"","sources":["../../../../src/orchestrate/common/structures/IAutoBeCommonCorrectDateApplication.ts"],"names":[],"mappings":""}

package/lib/orchestrate/realize/orchestrateRealizeCorrectDate.d.ts

@@ -1,4 +0,0 @@
-import { AutoBeProgressEventBase, AutoBeRealizeAuthorization, AutoBeRealizeFunction } from "@autobe/interface";
-import { ILlmSchema } from "@samchon/openapi";
-import { AutoBeContext } from "../../context/AutoBeContext";
-export declare const orchestrateRealizeCorrectDate: <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, authorizations: AutoBeRealizeAuthorization[], functions: AutoBeRealizeFunction[], progress: AutoBeProgressEventBase, life?: number) => Promise<AutoBeRealizeFunction[]>;