@autobe/agent 0.24.2 → 0.25.1

package/src/orchestrate/realize/orchestRateRealizeCorrectCasting.ts

@@ -14,9 +14,12 @@ import { v7 } from "uuid";
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
 import { executeCachedBatch } from "../../utils/executeCachedBatch";
-import { transformCommonCorrectCastingHistories } from "../common/histories/transformCommonCorrectCastingHistories";
 import { IAutoBeCommonCorrectCastingApplication } from "../common/structures/IAutoBeCommonCorrectCastingApplication";
+import { transformRealizeCorrectCastingHistories } from "./histories/transformRealizeCorrectCastingHistories";
 import { compileRealizeFiles } from "./internal/compileRealizeFiles";
+import { IAutoBeRealizeScenarioResult } from "./structures/IAutoBeRealizeScenarioResult";
+import { getRealizeWriteCodeTemplate } from "./utils/getRealizeWriteCodeTemplate";
+import { replaceImportStatements } from "./utils/replaceImportStatements";
 
 /** Result of attempting to correct a single function */
 type CorrectionResult = {
@@ -28,6 +31,7 @@ export const orchestrateRealizeCorrectCasting = async <
   Model extends ILlmSchema.Model,
 >(
   ctx: AutoBeContext<Model>,
+  scenarios: IAutoBeRealizeScenarioResult[],
   authorizations: AutoBeRealizeAuthorization[],
   functions: AutoBeRealizeFunction[],
   progress: AutoBeProgressEventBase,
@@ -40,9 +44,9 @@ export const orchestrateRealizeCorrectCasting = async <
       functions,
     },
   );
-
   return predicate(
     ctx,
+    scenarios,
     authorizations,
     functions,
     [],
@@ -54,6 +58,7 @@ export const orchestrateRealizeCorrectCasting = async <
 
 const predicate = async <Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
+  scenarios: IAutoBeRealizeScenarioResult[],
   authorizations: AutoBeRealizeAuthorization[],
   functions: AutoBeRealizeFunction[],
   failures: IAutoBeTypeScriptCompileResult.IDiagnostic[],
@@ -63,9 +68,9 @@ const predicate = async <Model extends ILlmSchema.Model>(
 ): Promise<AutoBeRealizeFunction[]> => {
   if (event.result.type === "failure") {
     ctx.dispatch(event);
-
     return await correct(
       ctx,
+      scenarios,
       authorizations,
       functions,
       [...failures, ...event.result.diagnostics],
@@ -79,6 +84,7 @@ const predicate = async <Model extends ILlmSchema.Model>(
 
 const correct = async <Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
+  scenarios: IAutoBeRealizeScenarioResult[],
   authorizations: AutoBeRealizeAuthorization[],
   functions: AutoBeRealizeFunction[],
   failures: IAutoBeTypeScriptCompileResult.IDiagnostic[],
@@ -94,6 +100,12 @@ const correct = async <Model extends ILlmSchema.Model>(
   const locations: string[] = diagnose(event).filter((l) =>
     functions.map((f) => f.location).includes(l),
   );
+
+  // If no locations to correct, return original functions
+  if (locations.length === 0) {
+    return functions;
+  }
+
   progress.total += locations.length;
 
   const converted: CorrectionResult[] = await executeCachedBatch(
@@ -102,6 +114,13 @@ const correct = async <Model extends ILlmSchema.Model>(
         (f) => f.location === location,
       )!;
 
+      const scenario = scenarios.find((s) => s.location === func.location)!;
+
+      const operation = scenario.operation;
+      const authorization = authorizations.find(
+        (a) => a.role.name === operation.authorizationRole,
+      );
+
       const pointer: IPointer<
         IAutoBeCommonCorrectCastingApplication.IProps | false | null
       > = {
@@ -110,7 +129,7 @@ const correct = async <Model extends ILlmSchema.Model>(
 
       const { tokenUsage } = await ctx.conversate({
         source: "realizeCorrect",
-        histories: transformCommonCorrectCastingHistories([
+        histories: transformRealizeCorrectCastingHistories([
           {
             script: func.content,
             diagnostics: failures.filter((d) => d.file === location),
@@ -137,18 +156,62 @@ const correct = async <Model extends ILlmSchema.Model>(
 
           You don't need to explain me anything, but just fix or give it up 
           immediately without any hesitation, explanation, and questions.
+
+          The instruction to write at first was as follows, and the code you received is the code you wrote according to this instruction.
+          When modifying, modify the entire code, but not the import statement.
+
+          Below is template code you wrote:
+
+          ${getRealizeWriteCodeTemplate({
+            scenario,
+            schemas: ctx.state().interface!.document.components.schemas,
+            operation: scenario.operation,
+            authorization: authorization ?? null,
+          })}
+
+          Current code is as follows:
+
+          \`\`\`typescript
+          ${func.content}
+          \`\`\`
+
+          Also, never use typia.assert and typia.assertGuard like functions
+          to the Prisma types. Your mission is to fix the casting problem of
+          primitive types like string or number. Prisma type is not your scope.
+          
+          If you take a mistake that casting the Prisma type with the typia.assert
+          function, it would be fallen into the infinite compilation due to extremely
+          complicated Prisma type. Note that, the typia.assert function is allowed 
+          only in the individual property level string or literal type.
+
+          I repeat that, never assert the Prisma type. It's not your mission.
         `,
       });
       ++progress.completed;
+
       if (pointer.value === null)
         return { result: "exception" as const, func: func };
       else if (pointer.value === false)
         return { result: "ignore" as const, func: func };
 
+      pointer.value.draft = await replaceImportStatements(ctx, {
+        schemas: ctx.state().interface!.document.components.schemas,
+        operation: operation,
+        code: pointer.value.draft,
+        decoratorType: authorization?.payload.name,
+      });
+      if (pointer.value.revise.final)
+        pointer.value.revise.final = await replaceImportStatements(ctx, {
+          schemas: ctx.state().interface!.document.components.schemas,
+          operation: operation,
+          code: pointer.value.revise.final,
+          decoratorType: authorization?.payload.name,
+        });
+
       ctx.dispatch({
         id: v7(),
         type: "realizeCorrect",
-        content: pointer.value.revise.final,
+        content: pointer.value.revise.final ?? pointer.value.draft,
         created_at: new Date().toISOString(),
         location: func.location,
         step: ctx.state().analyze?.step ?? 0,
@@ -156,24 +219,48 @@ const correct = async <Model extends ILlmSchema.Model>(
         completed: progress.completed,
         total: progress.total,
       });
-
       return {
         result: "success" as const,
-        func: { ...func, content: pointer.value.revise.final },
+        func: {
+          ...func,
+          content: pointer.value.revise.final ?? pointer.value.draft,
+        },
       };
     }),
   );
 
+  // Get functions that were not modified (not in locations array)
+  const unchangedFunctions: AutoBeRealizeFunction[] = functions.filter(
+    (f) => !locations.includes(f.location),
+  );
+
+  // Merge converted functions with unchanged functions for validation
+  const allFunctionsForValidation = [
+    ...converted.map((c) => c.func),
+    ...unchangedFunctions,
+  ];
+
   const newValidate: AutoBeRealizeValidateEvent = await compileRealizeFiles(
     ctx,
     {
       authorizations,
-      functions: converted.map((c) => c.func),
+      functions: allFunctionsForValidation,
     },
   );
 
-  if (newValidate.result.type === "success") {
-    return converted.map((c) => c.func);
+  const newResult: IAutoBeTypeScriptCompileResult = newValidate.result;
+  if (newResult.type === "success") {
+    return allFunctionsForValidation;
+  } else if (newResult.type === "exception") {
+    // Compilation exception, return current functions. because retrying won't help.
+    return functions;
+  }
+
+  if (
+    newResult.diagnostics.every((d) => !d.file?.startsWith("src/providers"))
+  ) {
+    // No diagnostics related to provider functions, stop correcting
+    return allFunctionsForValidation;
   }
 
   const newLocations: string[] = diagnose(newValidate);
@@ -184,18 +271,16 @@ const correct = async <Model extends ILlmSchema.Model>(
     newLocations,
   );
 
-  // If no failures to retry, return success and ignored functions
+  // If no failures to retry, return all functions
   if (failed.length === 0) {
-    return [...success, ...ignored];
+    return [...success, ...ignored, ...unchangedFunctions];
   }
 
   // Collect diagnostics relevant to failed functions
   const failedLocations: string[] = failed.map((f) => f.location);
   const allDiagnostics: IAutoBeTypeScriptCompileResult.IDiagnostic[] = [
     ...failures,
-    ...(newValidate.result.type === "failure"
-      ? newValidate.result.diagnostics
-      : []),
+    ...(newResult.type === "failure" ? newResult.diagnostics : []),
   ];
   const relevantDiagnostics: IAutoBeTypeScriptCompileResult.IDiagnostic[] =
     filterRelevantDiagnostics(allDiagnostics, failedLocations);
@@ -203,6 +288,7 @@ const correct = async <Model extends ILlmSchema.Model>(
   // Recursively retry failed functions
   const retriedFunctions: AutoBeRealizeFunction[] = await predicate(
     ctx,
+    scenarios,
     authorizations,
     failed,
     relevantDiagnostics,
@@ -211,7 +297,7 @@ const correct = async <Model extends ILlmSchema.Model>(
     life - 1,
   );
 
-  return [...success, ...ignored, ...retriedFunctions];
+  return [...success, ...ignored, ...retriedFunctions, ...unchangedFunctions];
 };
 
 /**

package/src/orchestrate/realize/orchestrateRealize.ts

@@ -5,6 +5,7 @@ import {
   AutoBeRealizeAuthorization,
   AutoBeRealizeFunction,
   AutoBeRealizeHistory,
+  AutoBeRealizeValidateEvent,
   AutoBeRealizeWriteEvent,
   IAutoBeCompiler,
 } from "@autobe/interface";
@@ -19,7 +20,6 @@ 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 { IAutoBeRealizeScenarioResult } from "./structures/IAutoBeRealizeScenarioResult";
 import { generateRealizeScenario } from "./utils/generateRealizeScenario";
@@ -30,9 +30,9 @@ export const orchestrateRealize =
     props: IAutoBeApplicationProps,
   ): Promise<AutoBeAssistantMessageHistory | AutoBeRealizeHistory> => {
     // PREDICATION
-    const operations: AutoBeOpenApi.IOperation[] | undefined =
-      ctx.state().interface?.document.operations;
-    if (!operations)
+    const document: AutoBeOpenApi.IDocument | undefined =
+      ctx.state().interface?.document;
+    if (document === undefined)
       throw new Error("Can't do realize agent because operations are nothing.");
 
     const start: Date = new Date();
@@ -52,116 +52,156 @@ export const orchestrateRealize =
       type: "realizeStart",
       id: v7(),
       created_at: start.toISOString(),
-      reason: props.reason,
+      reason: props.instruction,
       step: ctx.state().test?.step ?? 0,
     });
 
-    // AUTHORIZATIONS
+    // PREPARE ASSETS
+    const compiler: IAutoBeCompiler = await ctx.compiler();
     const authorizations: AutoBeRealizeAuthorization[] =
       await orchestrateRealizeAuthorization(ctx);
 
-    // SCENARIOS
-    const scenarios: IAutoBeRealizeScenarioResult[] = operations.map(
-      (operation) => generateRealizeScenario(ctx, operation, authorizations),
-    );
-
     const writeProgress: AutoBeProgressEventBase = {
-      total: scenarios.length,
+      total: document.operations.length,
       completed: 0,
     };
-    const writeEvents: (AutoBeRealizeWriteEvent | null)[] =
-      await executeCachedBatch(
-        scenarios.map((scenario) => async (promptCacheKey) => {
-          const props = {
-            totalAuthorizations: authorizations,
-            authorization: scenario.decoratorEvent ?? null,
-            scenario,
-            progress: writeProgress,
-            promptCacheKey,
-          };
-
-          const code: AutoBeRealizeWriteEvent | null =
-            await orchestrateRealizeWrite(ctx, props).catch(() => {
-              return orchestrateRealizeWrite(ctx, props).catch(() => null);
-            });
-
-          return code;
-        }),
-      );
-
-    const functions: AutoBeRealizeFunction[] = Object.entries(
-      Object.fromEntries(
-        writeEvents
-          .filter((w) => w !== null)
-          .map((event) => [event.location, event.content]),
-      ),
-    ).map(([location, content]) => {
-      const scenario = scenarios.find((el) => el.location === location)!;
-      return {
-        location,
-        content,
-        endpoint: {
-          method: scenario.operation.method,
-          path: scenario.operation.path,
-        },
-        name: scenario.functionName,
-      };
-    });
-
-    const reviewProgress: AutoBeProgressEventBase = {
-      total: writeEvents.length,
-      completed: writeEvents.length,
+    const correctProgress: AutoBeProgressEventBase = {
+      total: document.operations.length,
+      completed: 0,
     };
 
-    console.log("casting", reviewProgress);
-    const totalCorrected: AutoBeRealizeFunction[] =
-      await orchestrateRealizeCorrectCasting(
-        ctx,
-        authorizations,
-        functions,
-        reviewProgress,
-      ).then(async (res) => {
-        console.log("date", reviewProgress);
-        return orchestrateRealizeCorrectDate(
+    const process = async (
+      artifacts: IAutoBeRealizeScenarioResult[],
+    ): Promise<IBucket> => {
+      const writes: AutoBeRealizeWriteEvent[] = (
+        await executeCachedBatch(
+          artifacts.map((art) => async (promptCacheKey) => {
+            const props = {
+              totalAuthorizations: authorizations,
+              authorization: art.decoratorEvent ?? null,
+              scenario: art,
+              document,
+              progress: writeProgress,
+              promptCacheKey,
+            };
+            try {
+              return await orchestrateRealizeWrite(ctx, props);
+            } catch {
+              try {
+                return await orchestrateRealizeWrite(ctx, props);
+              } catch {
+                return null;
+              }
+            }
+          }),
+        )
+      ).filter((w) => w !== null);
+      const functions: AutoBeRealizeFunction[] = Object.entries(
+        Object.fromEntries(writes.map((w) => [w.location, w.content])),
+      ).map(([location, content]) => {
+        const scenario: IAutoBeRealizeScenarioResult = artifacts.find(
+          (el) => el.location === location,
+        )!;
+        return {
+          location,
+          content,
+          endpoint: {
+            method: scenario.operation.method,
+            path: scenario.operation.path,
+          },
+          name: scenario.functionName,
+        };
+      });
+      const corrected: AutoBeRealizeFunction[] =
+        await orchestrateRealizeCorrectCasting(
           ctx,
+          artifacts,
           authorizations,
-          res,
-          reviewProgress,
+          functions,
+          correctProgress,
         ).then(async (res) => {
-          console.log("correct", reviewProgress);
-          return orchestrateRealizeCorrect(
+          return await orchestrateRealizeCorrect(
             ctx,
-            scenarios,
+            artifacts,
             authorizations,
             res,
             [],
-            reviewProgress,
+            correctProgress,
           );
         });
-      });
+      const validate: AutoBeRealizeValidateEvent = await compileRealizeFiles(
+        ctx,
+        {
+          authorizations,
+          functions: corrected,
+        },
+      );
+      return {
+        corrected,
+        validate,
+      };
+    };
+
+    // SCENARIOS
+    const entireScenarios: IAutoBeRealizeScenarioResult[] =
+      document.operations.map((operation) =>
+        generateRealizeScenario(ctx, operation, authorizations),
+      );
+    let bucket: IBucket = await process(entireScenarios);
+    for (let i: number = 0; i < 2; ++i) {
+      if (bucket.validate.result.type !== "failure") break;
+
+      const failedScenarios: IAutoBeRealizeScenarioResult[] = Array.from(
+        new Set(bucket.validate.result.diagnostics.map((f) => f.file)),
+      )
+        .map((location) =>
+          bucket.corrected.find((f) => f.location === location),
+        )
+        .filter((f) => f !== undefined)
+        .map((f) =>
+          entireScenarios.find(
+            (s) =>
+              s.operation.path === f.endpoint.path &&
+              s.operation.method === f.endpoint.method,
+          ),
+        )
+        .filter((o) => o !== undefined);
+      if (failedScenarios.length === 0) break;
+
+      writeProgress.total += failedScenarios.length;
+      correctProgress.total += failedScenarios.length;
+
+      const newBucket: IBucket = await process(failedScenarios);
+      const corrected: Map<string, AutoBeRealizeFunction> = new Map([
+        ...bucket.corrected.map((f) => [f.location, f] as const),
+        ...newBucket.corrected.map((f) => [f.location, f] as const),
+      ]);
+      bucket = {
+        corrected: Array.from(corrected.values()),
+        validate: newBucket.validate,
+      };
+    }
 
-    const compiler: IAutoBeCompiler = await ctx.compiler();
     const controllers: Record<string, string> =
       await compiler.realize.controller({
         document: ctx.state().interface!.document,
-        functions: totalCorrected,
+        functions: bucket.corrected,
         authorizations,
       });
-
-    const { result } = await compileRealizeFiles(ctx, {
-      authorizations,
-      functions: totalCorrected,
-    });
-
     return ctx.dispatch({
       type: "realizeComplete",
       id: v7(),
       created_at: new Date().toISOString(),
-      functions,
+      functions: bucket.corrected,
       authorizations,
       controllers,
-      compiled: result,
+      compiled: bucket.validate.result,
       step: ctx.state().analyze?.step ?? 0,
       elapsed: new Date().getTime() - start.getTime(),
     });
   };
+
+interface IBucket {
+  corrected: AutoBeRealizeFunction[];
+  validate: AutoBeRealizeValidateEvent;
+}

package/src/orchestrate/realize/orchestrateRealizeCorrect.ts

@@ -19,6 +19,7 @@ import { IAutoBeRealizeCorrectApplication } from "./structures/IAutoBeRealizeCor
 import { IAutoBeRealizeFunctionFailure } from "./structures/IAutoBeRealizeFunctionFailure";
 import { IAutoBeRealizeScenarioResult } from "./structures/IAutoBeRealizeScenarioResult";
 import { filterDiagnostics } from "./utils/filterDiagnostics";
+import { getRealizeWriteCodeTemplate } from "./utils/getRealizeWriteCodeTemplate";
 import { getRealizeWriteDto } from "./utils/getRealizeWriteDto";
 import { replaceImportStatements } from "./utils/replaceImportStatements";
 
@@ -40,6 +41,16 @@ export async function orchestrateRealizeCorrect<Model extends ILlmSchema.Model>(
 
   // Extract and process diagnostics
   const diagnostics = event.result.diagnostics;
+
+  if (
+    event.result.diagnostics.every(
+      (d) => !d.file?.startsWith("src/providers"),
+    ) === true
+  ) {
+    // No diagnostics related to provider functions, stop correcting
+    return functions;
+  }
+
   const locations: string[] = Array.from(
     new Set(
       diagnostics
@@ -91,7 +102,6 @@ export async function orchestrateRealizeCorrect<Model extends ILlmSchema.Model>(
     ),
     progress,
   );
-
   return orchestrateRealizeCorrect(
     ctx,
     scenarios,
@@ -115,7 +125,11 @@ async function correct<Model extends ILlmSchema.Model>(
   failures: IAutoBeRealizeFunctionFailure[],
   progress: AutoBeProgressEventBase,
 ): Promise<AutoBeRealizeFunction[]> {
-  const result: AutoBeRealizeFunction[] = await executeCachedBatch(
+  if (locations.length === 0) {
+    return functions;
+  }
+
+  const corrected: 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);
@@ -154,7 +168,11 @@ async function correct<Model extends ILlmSchema.Model>(
     }),
   );
 
-  return result;
+  // Create a map of corrected functions for efficient lookup
+  const correctedMap = new Map(corrected.map((f) => [f.location, f]));
+
+  // Return all functions, with corrected ones replaced
+  return functions.map((func) => correctedMap.get(func.location) || func);
 }
 
 async function step<Model extends ILlmSchema.Model>(
@@ -195,6 +213,23 @@ async function step<Model extends ILlmSchema.Model>(
     enforceFunctionCall: true,
     message: StringUtil.trim`
       Correct the TypeScript code implementation.
+
+      The instruction to write at first was as follows, and the code you received is the code you wrote according to this instruction.
+      When modifying, modify the entire code, but not the import statement.
+
+      Below is template code you wrote:
+      
+      ${getRealizeWriteCodeTemplate({
+        scenario: props.scenario,
+        schemas: ctx.state().interface!.document.components.schemas,
+        operation: props.scenario.operation,
+        authorization: props.authorization ?? null,
+      })}
+
+      Current code is as follows:
+      \`\`\`typescript
+      ${props.function.content}
+      \`\`\`
     `,
   });
 
@@ -202,17 +237,25 @@ async function step<Model extends ILlmSchema.Model>(
     return null;
   }
 
-  pointer.value.revise.final = await replaceImportStatements(ctx, {
+  pointer.value.draft = await replaceImportStatements(ctx, {
     operation: props.scenario.operation,
-    code: pointer.value.revise.final,
+    schemas: ctx.state().interface!.document.components.schemas,
+    code: pointer.value.draft,
     decoratorType: props.authorization?.payload.name,
   });
+  if (pointer.value.revise.final)
+    pointer.value.revise.final = await replaceImportStatements(ctx, {
+      operation: props.scenario.operation,
+      schemas: ctx.state().interface!.document.components.schemas,
+      code: pointer.value.revise.final,
+      decoratorType: props.authorization?.payload.name,
+    });
 
   const event: AutoBeRealizeCorrectEvent = {
     type: "realizeCorrect",
     id: v7(),
     location: props.scenario.location,
-    content: pointer.value.revise.final,
+    content: pointer.value.revise.final ?? pointer.value.draft,
     tokenUsage,
     completed: ++props.progress.completed,
     total: props.progress.total,
@@ -237,7 +280,7 @@ function createController<Model extends ILlmSchema.Model>(props: {
     name: "Write code",
     application,
     execute: {
-      review: (next) => {
+      correct: (next) => {
         props.build(next);
       },
     } satisfies IAutoBeRealizeCorrectApplication,

package/src/orchestrate/realize/orchestrateRealizeWrite.ts

@@ -1,4 +1,5 @@
 import {
+  AutoBeOpenApi,
   AutoBeProgressEventBase,
   AutoBeRealizeAuthorization,
   AutoBeRealizeWriteEvent,
@@ -20,6 +21,7 @@ import { replaceImportStatements } from "./utils/replaceImportStatements";
 export async function orchestrateRealizeWrite<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   props: {
+    document: AutoBeOpenApi.IDocument;
     totalAuthorizations: AutoBeRealizeAuthorization[];
     authorization: AutoBeRealizeAuthorization | null;
     scenario: IAutoBeRealizeScenarioResult;
@@ -69,17 +71,25 @@ export async function orchestrateRealizeWrite<Model extends ILlmSchema.Model>(
   });
   if (pointer.value === null) throw new Error("Failed to write code.");
 
-  pointer.value.final = await replaceImportStatements(ctx, {
+  pointer.value.draft = await replaceImportStatements(ctx, {
     operation: props.scenario.operation,
-    code: pointer.value.final,
+    schemas: props.document.components.schemas,
+    code: pointer.value.draft,
     decoratorType: props.authorization?.payload.name,
   });
+  if (pointer.value.revise.final)
+    pointer.value.revise.final = await replaceImportStatements(ctx, {
+      operation: props.scenario.operation,
+      schemas: props.document.components.schemas,
+      code: pointer.value.revise.final,
+      decoratorType: props.authorization?.payload.name,
+    });
 
   const event: AutoBeRealizeWriteEvent = {
     type: "realizeWrite",
     id: v7(),
     location: props.scenario.location,
-    content: pointer.value.final,
+    content: pointer.value.revise.final ?? pointer.value.draft,
     tokenUsage,
     completed: ++props.progress.completed,
     total: props.progress.total,
@@ -105,7 +115,7 @@ function createController<Model extends ILlmSchema.Model>(props: {
     name: "Write code",
     application,
     execute: {
-      coding: (next) => {
+      write: (next) => {
         props.build(next);
       },
     } satisfies IAutoBeRealizeWriteApplication,