@autobe/agent 0.10.6 → 0.11.1

package/lib/orchestrate/realize/orchestrateRealizeCoder.js

@@ -52,7 +52,7 @@ const typia_1 = __importDefault(require("typia"));
 const assertSchemaModel_1 = require("../../context/assertSchemaModel");
 const enforceToolCall_1 = require("../../utils/enforceToolCall");
 const getTestScenarioArtifacts_1 = require("../test/compile/getTestScenarioArtifacts");
-const orchestrateRealize_1 = require("./orchestrateRealize");
+const IAutoBeRealizeFailedSymbol_1 = require("./structures/IAutoBeRealizeFailedSymbol");
 const transformRealizeCoderHistories_1 = require("./transformRealizeCoderHistories");
 /**
  * Generates a TypeScript function implementation based on the given plan.
@@ -72,7 +72,7 @@ const transformRealizeCoderHistories_1 = require("./transformRealizeCoderHistori
  * @param props - Planning result describing what function to generate
  * @returns The generated function name and TypeScript code
  */
-const orchestrateRealizeCoder = (ctx, operation, props, files) => __awaiter(void 0, void 0, void 0, function* () {
+const orchestrateRealizeCoder = (ctx, operation, props, previous, total, diagnostics) => __awaiter(void 0, void 0, void 0, function* () {
     const artifacts = yield (0, getTestScenarioArtifacts_1.getTestScenarioArtifacts)(ctx, {
         endpoint: {
             method: operation.method,
@@ -86,7 +86,7 @@ const orchestrateRealizeCoder = (ctx, operation, props, files) => __awaiter(void
     const controller = createApplication({
         model: ctx.model,
         build: (props) => {
-            pointer.value = props.result;
+            pointer.value = props.output;
         },
     });
     const agent = new core_1.MicroAgentica({
@@ -96,34 +96,46 @@ const orchestrateRealizeCoder = (ctx, operation, props, files) => __awaiter(void
         config: Object.assign(Object.assign({}, ctx.config), { executor: {
                 describe: null,
             } }),
-        histories: (0, transformRealizeCoderHistories_1.transformRealizeCoderHistories)(ctx.state(), props, artifacts),
+        histories: (0, transformRealizeCoderHistories_1.transformRealizeCoderHistories)(ctx.state(), props, artifacts, previous, total, diagnostics),
     });
     (0, enforceToolCall_1.enforceToolCall)(agent);
     yield agent.conversate("Write code.");
     const tokenUsage = agent.getTokenUsage();
     ctx.usage().record(tokenUsage, ["realize"]);
     if (pointer.value === null) {
-        return orchestrateRealize_1.FAILED;
+        return IAutoBeRealizeFailedSymbol_1.FAILED;
     }
-    pointer.value.implementationCode = yield ctx.compiler.typescript.beautify(pointer.value.implementationCode);
-    pointer.value.implementationCode = pointer.value.implementationCode
-        .replaceAll('import { MyGlobal } from "../MyGlobal";', "")
-        .replaceAll('import typia, { tags } from "typia";', "")
-        .replaceAll('import { Prisma } from "@prisma/client";', "")
-        .replaceAll('import { jwtDecode } from "./jwtDecode"', "");
-    pointer.value.implementationCode = [
-        'import { MyGlobal } from "../MyGlobal";',
-        'import typia, { tags } from "typia";',
-        'import { Prisma } from "@prisma/client";',
-        'import { jwtDecode } from "./jwtDecode"',
-        "",
-        pointer.value.implementationCode,
-    ].join("\n");
-    files[`src/providers/${props.functionName}.ts`] =
-        pointer.value.implementationCode;
-    return Object.assign(Object.assign({}, pointer.value), { functionName: props.functionName });
+    pointer.value.implementationCode = yield replaceImportStatements(ctx)(pointer.value.implementationCode);
+    return Object.assign(Object.assign({}, pointer.value), { filename: `src/providers/${props.functionName}.ts` });
 });
 exports.orchestrateRealizeCoder = orchestrateRealizeCoder;
+function replaceImportStatements(ctx) {
+    return function (code) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const compiler = yield ctx.compiler();
+            code = yield compiler.typescript.beautify(code);
+            code = code
+                .replaceAll('import { MyGlobal } from "../MyGlobal";', "")
+                .replaceAll('import typia, { tags } from "typia";', "")
+                .replaceAll('import { tags } from "typia";', "")
+                .replaceAll('import { tags, typia } from "typia";', "")
+                .replaceAll('import typia from "typia";', "")
+                .replaceAll('import { Prisma } from "@prisma/client";', "")
+                .replaceAll('import { jwtDecode } from "./jwtDecode"', "")
+                .replaceAll('import { v4 } from "uuid"', "");
+            code = [
+                'import { MyGlobal } from "../MyGlobal";',
+                'import typia, { tags } from "typia";',
+                'import { Prisma } from "@prisma/client";',
+                'import { jwtDecode } from "./jwtDecode";',
+                'import { v4 } from "uuid";',
+                "",
+                code,
+            ].join("\n");
+            return code;
+        });
+    };
+}
 function createApplication(props) {
     (0, assertSchemaModel_1.assertSchemaModel)(props.model);
     const application = collection[props.model];
@@ -132,7 +144,7 @@ function createApplication(props) {
         name: "Write code",
         application,
         execute: {
-            programing: (next) => {
+            programming: (next) => {
                 props.build(next);
             },
         },
@@ -146,52 +158,79 @@ const claude = {
     },
     functions: [
         {
-            name: "programing",
+            name: "programming",
             parameters: {
-                description: "Current Type: {@link IAutoBeRealizeCoderApplication.IProps}",
+                description: "Description of the current {@link IAutoBeRealizeCoderApplication.IProps} type:\n\n> Properties for the component or function that consumes the output of the\n> code generation pipeline.",
                 type: "object",
                 properties: {
-                    result: {
+                    output: {
+                        description: "The detailed output of the code generation process, containing all phases\nfrom planning to final implementation of a TypeScript provider function.",
                         $ref: "#/$defs/IAutoBeRealizeCoderApplication.RealizeCoderOutput"
                     }
                 },
                 required: [
-                    "result"
+                    "output"
                 ],
                 additionalProperties: false,
                 $defs: {
                     "IAutoBeRealizeCoderApplication.RealizeCoderOutput": {
-                        description: "The result of the code generation step, representing a fully generated\nTypeScript function.",
+                        description: "Represents the complete output of a code generation pipeline. Each field\ncorresponds to a stage in the Chain of Thought (CoT) process for generating\na production-quality TypeScript function.\n\nAll fields contain TypeScript code strings and follow these rules:\n\n- All code must be valid TypeScript or structurally valid even if incomplete.\n- Each phase builds upon the previous one and must resolve specific concerns.\n- All phases must follow system conventions around structure, typing, and\n  logic.",
                         type: "object",
                         properties: {
-                            functionName: {
-                                description: "The name of the function to be generated.\n\nThis name will be used as the function's identifier and as the export\nname in the provider file.",
+                            filename: {
+                                description: "The name of the file to be generated (e.g., \"user.create.ts\")",
+                                type: "string"
+                            },
+                            plan: {
+                                description: "\uD83E\uDDE0 Provider Function Implementation Plan\n\nThis field outlines the strategic plan for implementing the provider\nfunction according to the Realize Coder Agent specification. Before\nwriting the actual code, think through the logic and structure.\n\nThe plan must consider:\n\n- \uD83E\uDDE9 Required business entities (e.g., users, posts, logs) and their\n  relationships\n- \uD83D\uDEE0 Operations needed to fulfill the business scenario (e.g., fetch,\n  create, update)\n- \uD83D\uDD04 Data dependencies between steps (e.g., use userId to fetch related\n  data)\n- \u2705 Validation points (based on business rules, not field presence)\n- \uD83D\uDEA7 Error and edge cases that must be handled explicitly (e.g., missing\n  records)\n- \uD83C\uDFD7 Structure: always a single `async function`, using only `parameters`\n  and `body`\n\n\u26A0\uFE0F Important Constraints:\n\n- Do NOT perform input validation \u2014 assume `parameters` and `body` are\n  already valid\n- Use `typia.random<T>()` with an explanatory comment if logic can't be\n  implemented\n- Never use `any` or make assumptions without sufficient context\n- Use only allowed imports \u2014 DTOs and Prisma types\n- Use `MyGlobal.prisma` for DB access and respect Prisma typing rules\n\n\u26A0\uFE0F TypeScript-specific considerations:\n\n- Do **not** use native `Date` objects directly; convert all dates with\n  `.toISOString()`\n- Use `string & tags.Format<'date-time'>` for all date/time typed fields\n- Prefer `satisfies` for DTO conformance instead of unsafe `as` casts\n- Avoid weak typing such as `any`, `as any`, or `satisfies any`\n- Use branded types (e.g., `tags.Format<'uuid'>`) and literal unions where\n  applicable\n\n\u2705 Example Structure:\n\n```ts\nexport async function doSomething(\n  user: { id: string & tags.Format<\"uuid\">; type: string },\n  parameters: IParams,\n  body: IBody\n): Promise<IReturn> {\n  const { id } = parameters;\n  const { name } = body;\n  const user = await MyGlobal.prisma.users.findFirst({ where: { id } });\n  if (!user) throw new Error(\"User not found\");\n  ...\n  return result;\n}\n```\n\n\uD83D\uDD25 Error Handling Plan:\n\nIf an error is expected or encountered during implementation:\n\n- Clearly document the error message(s) and TypeScript error codes.\n- Analyze the root cause (e.g., type mismatch, missing field, nullability\n  issue).\n- Define concrete steps to resolve the issue, such as:\n\n  - Adjusting type declarations or using Prisma-generated input types.\n  - Using `?? undefined` to normalize nullable fields.\n  - Applying correct relation handling (e.g., `connect` instead of direct\n      foreign key assignment).\n  - Ensuring `Date` fields use `.toISOString()` and branded types.\n- Include fallback or workaround plans if a direct fix is complex.\n- If no error is present, simply omit this section.\n\nThis plan ensures the function will:\n\n- Respect the global architecture and coding conventions\n- Be safe, predictable, and aligned with upstream logic",
+                                type: "string"
+                            },
+                            review: {
+                                description: "\uD83D\uDD0D Phase 2: Review code\n\nA refined version of the draft with improved completeness.\n\n- Replace placeholder logic with real DTO-conformant operations.\n- Add error handling (`throw new Error(...)`) where necessary.\n- Begin resolving structural or type mismatches.\n\n\u2705 Requirements:\n\n- Use `satisfies` to ensure DTO conformity.\n- Avoid unsafe `as` casts unless only for branding or literal narrowing.\n- Include `.toISOString()` for all date fields.\n- Ensure all object keys strictly conform to the expected type definitions.",
+                                type: "string"
+                            },
+                            withCompilerFeedback: {
+                                description: "\uD83D\uDEE0 Phase 3: With compiler feedback (optional)\n\nA correction pass that applies fixes for compile-time errors that arose\nduring the review stage (if any).\n\n\u2705 Must:\n\n- Resolve all TypeScript errors without using `as any`\n- Provide safe brand casting only if required (e.g., `as string &\n  tags.Format<'uuid'>`)",
                                 type: "string"
                             },
                             implementationCode: {
-                                description: "The raw TypeScript code string implementing the function.\n\n- The implementation must be valid TypeScript code.\n- It should focus solely on the logic of the function.\n- Import statements do **not** need to be included. They will be\n  automatically inserted by the system.\n- Any unused imports will be automatically removed by eslint.\n- Type annotations (e.g. for parameters and return types) should be omitted\n  if they can be inferred.",
+                                description: "\u2705 Phase 4: Final implementation\n\nThe complete and fully correct TypeScript function implementation.\n\n- Passes strict type checking without errors.\n- Uses only safe branding or literal type assertions.\n- Converts all Date values properly to ISO string format.\n- Follows DTO structures using `satisfies`.\n- Avoids any weak typing such as `any`, `as any`, or `satisfies any`.\n- Uses only allowed imports (e.g., from `src/api/structures` and\n  `MyGlobal.prisma`).\n\n\u26A0\uFE0F Prohibited Practices:\n\n- Do NOT add or modify import statements manually. Imports are handled\n  automatically by the system.\n- Do NOT use `any`, `as any`, or `satisfies any` to bypass type checking.\n- Do NOT assign native `Date` objects directly; always convert them to ISO\n  strings with `.toISOString()`.\n- Do NOT use unsafe type assertions except for safe branding or literal\n  narrowing.\n- Do NOT write code outside the single async function structure (e.g., no\n  classes or multiple functions).\n- Do NOT perform any input validation \u2014 assume all inputs are already\n  validated.\n- Do NOT use dynamic import expressions (`import()`); all imports must be\n  static.\n- Do NOT rely on DTO types for database update input; always use\n  Prisma-generated input types.",
                                 type: "string"
                             }
                         },
                         required: [
-                            "functionName",
+                            "filename",
+                            "plan",
+                            "review",
                             "implementationCode"
                         ]
                     }
                 }
             },
-            validate: (() => { const _io0 = input => "object" === typeof input.result && null !== input.result && _io1(input.result); const _io1 = input => "string" === typeof input.functionName && "string" === typeof input.implementationCode; const _vo0 = (input, _path, _exceptionable = true) => [("object" === typeof input.result && null !== input.result || _report(_exceptionable, {
-                    path: _path + ".result",
+            validate: (() => { const _io0 = input => "object" === typeof input.output && null !== input.output && _io1(input.output); const _io1 = input => "string" === typeof input.filename && "string" === typeof input.plan && "string" === typeof input.review && (undefined === input.withCompilerFeedback || "string" === typeof input.withCompilerFeedback) && "string" === typeof input.implementationCode; const _vo0 = (input, _path, _exceptionable = true) => [("object" === typeof input.output && null !== input.output || _report(_exceptionable, {
+                    path: _path + ".output",
                     expected: "IAutoBeRealizeCoderApplication.RealizeCoderOutput",
-                    value: input.result
-                })) && _vo1(input.result, _path + ".result", true && _exceptionable) || _report(_exceptionable, {
-                    path: _path + ".result",
+                    value: input.output
+                })) && _vo1(input.output, _path + ".output", true && _exceptionable) || _report(_exceptionable, {
+                    path: _path + ".output",
                     expected: "IAutoBeRealizeCoderApplication.RealizeCoderOutput",
-                    value: input.result
-                })].every(flag => flag); const _vo1 = (input, _path, _exceptionable = true) => ["string" === typeof input.functionName || _report(_exceptionable, {
-                    path: _path + ".functionName",
+                    value: input.output
+                })].every(flag => flag); const _vo1 = (input, _path, _exceptionable = true) => ["string" === typeof input.filename || _report(_exceptionable, {
+                    path: _path + ".filename",
+                    expected: "string",
+                    value: input.filename
+                }), "string" === typeof input.plan || _report(_exceptionable, {
+                    path: _path + ".plan",
                     expected: "string",
-                    value: input.functionName
+                    value: input.plan
+                }), "string" === typeof input.review || _report(_exceptionable, {
+                    path: _path + ".review",
+                    expected: "string",
+                    value: input.review
+                }), undefined === input.withCompilerFeedback || "string" === typeof input.withCompilerFeedback || _report(_exceptionable, {
+                    path: _path + ".withCompilerFeedback",
+                    expected: "(string | undefined)",
+                    value: input.withCompilerFeedback
                 }), "string" === typeof input.implementationCode || _report(_exceptionable, {
                     path: _path + ".implementationCode",
                     expected: "string",
@@ -237,52 +276,78 @@ const collection = {
         },
         functions: [
             {
-                name: "programing",
+                name: "programming",
                 parameters: {
-                    description: "Current Type: {@link IAutoBeRealizeCoderApplication.IProps}",
+                    description: "Description of the current {@link IAutoBeRealizeCoderApplication.IProps} type:\n\n> Properties for the component or function that consumes the output of the\n> code generation pipeline.\n\n### Description of {@link output} property:\n\n> The detailed output of the code generation process, containing all phases\n> from planning to final implementation of a TypeScript provider function.",
                     type: "object",
                     properties: {
-                        result: {
+                        output: {
                             $ref: "#/$defs/IAutoBeRealizeCoderApplication.RealizeCoderOutput"
                         }
                     },
                     required: [
-                        "result"
+                        "output"
                     ],
                     additionalProperties: false,
                     $defs: {
                         "IAutoBeRealizeCoderApplication.RealizeCoderOutput": {
-                            description: "The result of the code generation step, representing a fully generated\nTypeScript function.",
+                            description: "Represents the complete output of a code generation pipeline. Each field\ncorresponds to a stage in the Chain of Thought (CoT) process for generating\na production-quality TypeScript function.\n\nAll fields contain TypeScript code strings and follow these rules:\n\n- All code must be valid TypeScript or structurally valid even if incomplete.\n- Each phase builds upon the previous one and must resolve specific concerns.\n- All phases must follow system conventions around structure, typing, and\n  logic.",
                             type: "object",
                             properties: {
-                                functionName: {
-                                    description: "The name of the function to be generated.\n\nThis name will be used as the function's identifier and as the export\nname in the provider file.",
+                                filename: {
+                                    description: "The name of the file to be generated (e.g., \"user.create.ts\")",
+                                    type: "string"
+                                },
+                                plan: {
+                                    description: "\uD83E\uDDE0 Provider Function Implementation Plan\n\nThis field outlines the strategic plan for implementing the provider\nfunction according to the Realize Coder Agent specification. Before\nwriting the actual code, think through the logic and structure.\n\nThe plan must consider:\n\n- \uD83E\uDDE9 Required business entities (e.g., users, posts, logs) and their\n  relationships\n- \uD83D\uDEE0 Operations needed to fulfill the business scenario (e.g., fetch,\n  create, update)\n- \uD83D\uDD04 Data dependencies between steps (e.g., use userId to fetch related\n  data)\n- \u2705 Validation points (based on business rules, not field presence)\n- \uD83D\uDEA7 Error and edge cases that must be handled explicitly (e.g., missing\n  records)\n- \uD83C\uDFD7 Structure: always a single `async function`, using only `parameters`\n  and `body`\n\n\u26A0\uFE0F Important Constraints:\n\n- Do NOT perform input validation \u2014 assume `parameters` and `body` are\n  already valid\n- Use `typia.random<T>()` with an explanatory comment if logic can't be\n  implemented\n- Never use `any` or make assumptions without sufficient context\n- Use only allowed imports \u2014 DTOs and Prisma types\n- Use `MyGlobal.prisma` for DB access and respect Prisma typing rules\n\n\u26A0\uFE0F TypeScript-specific considerations:\n\n- Do **not** use native `Date` objects directly; convert all dates with\n  `.toISOString()`\n- Use `string & tags.Format<'date-time'>` for all date/time typed fields\n- Prefer `satisfies` for DTO conformance instead of unsafe `as` casts\n- Avoid weak typing such as `any`, `as any`, or `satisfies any`\n- Use branded types (e.g., `tags.Format<'uuid'>`) and literal unions where\n  applicable\n\n\u2705 Example Structure:\n\n```ts\nexport async function doSomething(\n  user: { id: string & tags.Format<\"uuid\">; type: string },\n  parameters: IParams,\n  body: IBody\n): Promise<IReturn> {\n  const { id } = parameters;\n  const { name } = body;\n  const user = await MyGlobal.prisma.users.findFirst({ where: { id } });\n  if (!user) throw new Error(\"User not found\");\n  ...\n  return result;\n}\n```\n\n\uD83D\uDD25 Error Handling Plan:\n\nIf an error is expected or encountered during implementation:\n\n- Clearly document the error message(s) and TypeScript error codes.\n- Analyze the root cause (e.g., type mismatch, missing field, nullability\n  issue).\n- Define concrete steps to resolve the issue, such as:\n\n  - Adjusting type declarations or using Prisma-generated input types.\n  - Using `?? undefined` to normalize nullable fields.\n  - Applying correct relation handling (e.g., `connect` instead of direct\n      foreign key assignment).\n  - Ensuring `Date` fields use `.toISOString()` and branded types.\n- Include fallback or workaround plans if a direct fix is complex.\n- If no error is present, simply omit this section.\n\nThis plan ensures the function will:\n\n- Respect the global architecture and coding conventions\n- Be safe, predictable, and aligned with upstream logic",
+                                    type: "string"
+                                },
+                                review: {
+                                    description: "\uD83D\uDD0D Phase 2: Review code\n\nA refined version of the draft with improved completeness.\n\n- Replace placeholder logic with real DTO-conformant operations.\n- Add error handling (`throw new Error(...)`) where necessary.\n- Begin resolving structural or type mismatches.\n\n\u2705 Requirements:\n\n- Use `satisfies` to ensure DTO conformity.\n- Avoid unsafe `as` casts unless only for branding or literal narrowing.\n- Include `.toISOString()` for all date fields.\n- Ensure all object keys strictly conform to the expected type definitions.",
+                                    type: "string"
+                                },
+                                withCompilerFeedback: {
+                                    description: "\uD83D\uDEE0 Phase 3: With compiler feedback (optional)\n\nA correction pass that applies fixes for compile-time errors that arose\nduring the review stage (if any).\n\n\u2705 Must:\n\n- Resolve all TypeScript errors without using `as any`\n- Provide safe brand casting only if required (e.g., `as string &\n  tags.Format<'uuid'>`)",
                                     type: "string"
                                 },
                                 implementationCode: {
-                                    description: "The raw TypeScript code string implementing the function.\n\n- The implementation must be valid TypeScript code.\n- It should focus solely on the logic of the function.\n- Import statements do **not** need to be included. They will be\n  automatically inserted by the system.\n- Any unused imports will be automatically removed by eslint.\n- Type annotations (e.g. for parameters and return types) should be omitted\n  if they can be inferred.",
+                                    description: "\u2705 Phase 4: Final implementation\n\nThe complete and fully correct TypeScript function implementation.\n\n- Passes strict type checking without errors.\n- Uses only safe branding or literal type assertions.\n- Converts all Date values properly to ISO string format.\n- Follows DTO structures using `satisfies`.\n- Avoids any weak typing such as `any`, `as any`, or `satisfies any`.\n- Uses only allowed imports (e.g., from `src/api/structures` and\n  `MyGlobal.prisma`).\n\n\u26A0\uFE0F Prohibited Practices:\n\n- Do NOT add or modify import statements manually. Imports are handled\n  automatically by the system.\n- Do NOT use `any`, `as any`, or `satisfies any` to bypass type checking.\n- Do NOT assign native `Date` objects directly; always convert them to ISO\n  strings with `.toISOString()`.\n- Do NOT use unsafe type assertions except for safe branding or literal\n  narrowing.\n- Do NOT write code outside the single async function structure (e.g., no\n  classes or multiple functions).\n- Do NOT perform any input validation \u2014 assume all inputs are already\n  validated.\n- Do NOT use dynamic import expressions (`import()`); all imports must be\n  static.\n- Do NOT rely on DTO types for database update input; always use\n  Prisma-generated input types.",
                                     type: "string"
                                 }
                             },
                             required: [
-                                "functionName",
+                                "filename",
+                                "plan",
+                                "review",
                                 "implementationCode"
                             ]
                         }
                     }
                 },
-                validate: (() => { const _io0 = input => "object" === typeof input.result && null !== input.result && _io1(input.result); const _io1 = input => "string" === typeof input.functionName && "string" === typeof input.implementationCode; const _vo0 = (input, _path, _exceptionable = true) => [("object" === typeof input.result && null !== input.result || _report(_exceptionable, {
-                        path: _path + ".result",
+                validate: (() => { const _io0 = input => "object" === typeof input.output && null !== input.output && _io1(input.output); const _io1 = input => "string" === typeof input.filename && "string" === typeof input.plan && "string" === typeof input.review && (undefined === input.withCompilerFeedback || "string" === typeof input.withCompilerFeedback) && "string" === typeof input.implementationCode; const _vo0 = (input, _path, _exceptionable = true) => [("object" === typeof input.output && null !== input.output || _report(_exceptionable, {
+                        path: _path + ".output",
                         expected: "IAutoBeRealizeCoderApplication.RealizeCoderOutput",
-                        value: input.result
-                    })) && _vo1(input.result, _path + ".result", true && _exceptionable) || _report(_exceptionable, {
-                        path: _path + ".result",
+                        value: input.output
+                    })) && _vo1(input.output, _path + ".output", true && _exceptionable) || _report(_exceptionable, {
+                        path: _path + ".output",
                         expected: "IAutoBeRealizeCoderApplication.RealizeCoderOutput",
-                        value: input.result
-                    })].every(flag => flag); const _vo1 = (input, _path, _exceptionable = true) => ["string" === typeof input.functionName || _report(_exceptionable, {
-                        path: _path + ".functionName",
+                        value: input.output
+                    })].every(flag => flag); const _vo1 = (input, _path, _exceptionable = true) => ["string" === typeof input.filename || _report(_exceptionable, {
+                        path: _path + ".filename",
+                        expected: "string",
+                        value: input.filename
+                    }), "string" === typeof input.plan || _report(_exceptionable, {
+                        path: _path + ".plan",
+                        expected: "string",
+                        value: input.plan
+                    }), "string" === typeof input.review || _report(_exceptionable, {
+                        path: _path + ".review",
                         expected: "string",
-                        value: input.functionName
+                        value: input.review
+                    }), undefined === input.withCompilerFeedback || "string" === typeof input.withCompilerFeedback || _report(_exceptionable, {
+                        path: _path + ".withCompilerFeedback",
+                        expected: "(string | undefined)",
+                        value: input.withCompilerFeedback
                     }), "string" === typeof input.implementationCode || _report(_exceptionable, {
                         path: _path + ".implementationCode",
                         expected: "string",

package/lib/orchestrate/realize/orchestrateRealizeCoder.js.map

@@ -1 +1 @@
-{"version":3,"file":"orchestrateRealizeCoder.js","sourceRoot":"","sources":["../../../src/orchestrate/realize/orchestrateRealizeCoder.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,yCAAoE;AAIpE,kDAA0B;AAG1B,uEAAoE;AACpE,iEAA8D;AAC9D,uFAAoF;AAEpF,6DAA8C;AAG9C,qFAAkF;AAElF;;;;;;;;;;;;;;;;;GAiBG;AACI,MAAM,uBAAuB,GAAG,CACrC,GAAyB,EACzB,SAAmC,EACnC,KAA2B,EAC3B,KAA6B,EACwC,EAAE;IACvE,MAAM,SAAS,GACb,MAAM,IAAA,mDAAwB,EAAC,GAAG,EAAE;QAClC,QAAQ,EAAE;YACR,MAAM,EAAE,SAAS,CAAC,MAAM;YACxB,IAAI,EAAE,SAAS,CAAC,IAAI;SACrB;QACD,YAAY,EAAE,EAAE;KACjB,CAAC,CAAC;IAEL,MAAM,OAAO,GAGD;QACV,KAAK,EAAE,IAAI;KACZ,CAAC;IAEF,MAAM,UAAU,GAAG,iBAAiB,CAAC;QACnC,KAAK,EAAE,GAAG,CAAC,KAAK;QAChB,KAAK,EAAE,CAAC,KAAK,EAAE,EAAE;YACf,OAAO,CAAC,KAAK,GAAG,KAAK,CAAC,MAAM,CAAC;QAC/B,CAAC;KACF,CAAC,CAAC;IAEH,MAAM,KAAK,GAAG,IAAI,oBAAa,CAAC;QAC9B,WAAW,EAAE,CAAC,UAAU,CAAC;QACzB,KAAK,EAAE,GAAG,CAAC,KAAK;QAChB,MAAM,EAAE,GAAG,CAAC,MAAM;QAClB,MAAM,kCACD,GAAG,CAAC,MAAM,KACb,QAAQ,EAAE;gBACR,QAAQ,EAAE,IAAI;aACf,GACF;QACD,SAAS,EAAE,IAAA,+DAA8B,EAAC,GAAG,CAAC,KAAK,EAAE,EAAE,KAAK,EAAE,SAAS,CAAC;KACzE,CAAC,CAAC;IACH,IAAA,iCAAe,EAAC,KAAK,CAAC,CAAC;IAEvB,MAAM,KAAK,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC;IACtC,MAAM,UAAU,GAAG,KAAK,CAAC,aAAa,EAAE,CAAC;IACzC,GAAG,CAAC,KAAK,EAAE,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC,SAAS,CAAC,CAAC,CAAC;IAE5C,IAAI,OAAO,CAAC,KAAK,KAAK,IAAI,EAAE,CAAC;QAC3B,OAAO,2BAAM,CAAC;IAChB,CAAC;IAED,OAAO,CAAC,KAAK,CAAC,kBAAkB,GAAG,MAAM,GAAG,CAAC,QAAQ,CAAC,UAAU,CAAC,QAAQ,CACvE,OAAO,CAAC,KAAK,CAAC,kBAAkB,CACjC,CAAC;IACF,OAAO,CAAC,KAAK,CAAC,kBAAkB,GAAG,OAAO,CAAC,KAAK,CAAC,kBAAkB;SAChE,UAAU,CAAC,yCAAyC,EAAE,EAAE,CAAC;SACzD,UAAU,CAAC,sCAAsC,EAAE,EAAE,CAAC;SACtD,UAAU,CAAC,0CAA0C,EAAE,EAAE,CAAC;SAC1D,UAAU,CAAC,yCAAyC,EAAE,EAAE,CAAC,CAAC;IAC7D,OAAO,CAAC,KAAK,CAAC,kBAAkB,GAAG;QACjC,yCAAyC;QACzC,sCAAsC;QACtC,0CAA0C;QAC1C,yCAAyC;QACzC,EAAE;QACF,OAAO,CAAC,KAAK,CAAC,kBAAkB;KACjC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAEb,KAAK,CAAC,iBAAiB,KAAK,CAAC,YAAY,KAAK,CAAC;QAC7C,OAAO,CAAC,KAAK,CAAC,kBAAkB,CAAC;IAEnC,uCAAY,OAAO,CAAC,KAAK,KAAE,YAAY,EAAE,KAAK,CAAC,YAAY,IAAG;AAChE,CAAC,CAAA,CAAC;AAxEW,QAAA,uBAAuB,2BAwElC;AAEF,SAAS,iBAAiB,CAAiC,KAG1D;IACC,IAAA,qCAAiB,EAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAE/B,MAAM,WAAW,GAA2B,UAAU,CACpD,KAAK,CAAC,KAAK,CACyB,CAAC;IAEvC,OAAO;QACL,QAAQ,EAAE,OAAO;QACjB,IAAI,EAAE,YAAY;QAClB,WAAW;QACX,OAAO,EAAE;YACP,UAAU,EAAE,CAAC,IAAI,EAAE,EAAE;gBACnB,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YACpB,CAAC;SACuC;KAC3C,CAAC;AACJ,CAAC;AAED,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMT,CAAC;AACJ,MAAM,UAAU,GAAG;IACjB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAIJ;IACH,MAAM;IACN,KAAK,EAAE,MAAM;IACb,QAAQ,EAAE,MAAM;IAChB,KAAK,EAAE,MAAM;CACd,CAAC"}
+{"version":3,"file":"orchestrateRealizeCoder.js","sourceRoot":"","sources":["../../../src/orchestrate/realize/orchestrateRealizeCoder.ts"],"names":[],"mappings":"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"}

package/lib/orchestrate/realize/structures/IAutoBeRealizeCoderApplication.d.ts

@@ -1,34 +1,204 @@
 import { AutoBeOpenApi } from "@autobe/interface";
-import { FAILED } from "../orchestrateRealize";
+import { FAILED } from "./IAutoBeRealizeFailedSymbol";
 export interface IAutoBeRealizeCoderApplication {
-    programing: (next: IAutoBeRealizeCoderApplication.IProps) => void;
+    programming: (input: IAutoBeRealizeCoderApplication.IProps) => void;
 }
 export declare namespace IAutoBeRealizeCoderApplication {
+    /**
+     * Properties for the component or function that consumes the output of the
+     * code generation pipeline.
+     */
     interface IProps {
-        result: RealizeCoderOutput;
+        /**
+         * The detailed output of the code generation process, containing all phases
+         * from planning to final implementation of a TypeScript provider function.
+         */
+        output: RealizeCoderOutput;
     }
     /**
-     * The result of the code generation step, representing a fully generated
-     * TypeScript function.
+     * Represents the complete output of a code generation pipeline. Each field
+     * corresponds to a stage in the Chain of Thought (CoT) process for generating
+     * a production-quality TypeScript function.
+     *
+     * All fields contain TypeScript code strings and follow these rules:
+     *
+     * - All code must be valid TypeScript or structurally valid even if incomplete.
+     * - Each phase builds upon the previous one and must resolve specific concerns.
+     * - All phases must follow system conventions around structure, typing, and
+     *   logic.
      */
     interface RealizeCoderOutput {
+        /** The name of the file to be generated (e.g., "user.create.ts") */
+        filename: string;
         /**
-         * The name of the function to be generated.
+         * 🧠 Provider Function Implementation Plan
+         *
+         * This field outlines the strategic plan for implementing the provider
+         * function according to the Realize Coder Agent specification. Before
+         * writing the actual code, think through the logic and structure.
+         *
+         * The plan must consider:
+         *
+         * - 🧩 Required business entities (e.g., users, posts, logs) and their
+         *   relationships
+         * - 🛠 Operations needed to fulfill the business scenario (e.g., fetch,
+         *   create, update)
+         * - 🔄 Data dependencies between steps (e.g., use userId to fetch related
+         *   data)
+         * - ✅ Validation points (based on business rules, not field presence)
+         * - 🚧 Error and edge cases that must be handled explicitly (e.g., missing
+         *   records)
+         * - 🏗 Structure: always a single `async function`, using only `parameters`
+         *   and `body`
+         *
+         * ⚠️ Important Constraints:
+         *
+         * - Do NOT perform input validation — assume `parameters` and `body` are
+         *   already valid
+         * - Use `typia.random<T>()` with an explanatory comment if logic can't be
+         *   implemented
+         * - Never use `any` or make assumptions without sufficient context
+         * - Use only allowed imports — DTOs and Prisma types
+         * - Use `MyGlobal.prisma` for DB access and respect Prisma typing rules
+         *
+         * ⚠️ TypeScript-specific considerations:
+         *
+         * - Do **not** use native `Date` objects directly; convert all dates with
+         *   `.toISOString()`
+         * - Use `string & tags.Format<'date-time'>` for all date/time typed fields
+         * - Prefer `satisfies` for DTO conformance instead of unsafe `as` casts
+         * - Avoid weak typing such as `any`, `as any`, or `satisfies any`
+         * - Use branded types (e.g., `tags.Format<'uuid'>`) and literal unions where
+         *   applicable
          *
-         * This name will be used as the function's identifier and as the export
-         * name in the provider file.
+         * ✅ Example Structure:
+         *
+         * ```ts
+         * export async function doSomething(
+         *   user: { id: string & tags.Format<"uuid">; type: string },
+         *   parameters: IParams,
+         *   body: IBody
+         * ): Promise<IReturn> {
+         *   const { id } = parameters;
+         *   const { name } = body;
+         *   const user = await MyGlobal.prisma.users.findFirst({ where: { id } });
+         *   if (!user) throw new Error("User not found");
+         *   ...
+         *   return result;
+         * }
+         * ```
+         *
+         * 🔥 Error Handling Plan:
+         *
+         * If an error is expected or encountered during implementation:
+         *
+         * - Clearly document the error message(s) and TypeScript error codes.
+         * - Analyze the root cause (e.g., type mismatch, missing field, nullability
+         *   issue).
+         * - Define concrete steps to resolve the issue, such as:
+         *
+         *   - Adjusting type declarations or using Prisma-generated input types.
+         *   - Using `?? undefined` to normalize nullable fields.
+         *   - Applying correct relation handling (e.g., `connect` instead of direct
+         *       foreign key assignment).
+         *   - Ensuring `Date` fields use `.toISOString()` and branded types.
+         * - Include fallback or workaround plans if a direct fix is complex.
+         * - If no error is present, simply omit this section.
+         *
+         * This plan ensures the function will:
+         *
+         * - Respect the global architecture and coding conventions
+         * - Be safe, predictable, and aligned with upstream logic
          */
-        functionName: string;
+        plan: string;
         /**
-         * The raw TypeScript code string implementing the function.
-         *
-         * - The implementation must be valid TypeScript code.
-         * - It should focus solely on the logic of the function.
-         * - Import statements do **not** need to be included. They will be
-         *   automatically inserted by the system.
-         * - Any unused imports will be automatically removed by eslint.
-         * - Type annotations (e.g. for parameters and return types) should be omitted
-         *   if they can be inferred.
+         * ✏️ Phase 1: Draft code
+         *
+         * This is the initial drafting phase where you outline the basic skeleton
+         * of the function.
+         *
+         * - The function signature must correctly include `user`, `parameters`, and
+         *   `body` arguments.
+         * - Design the main flow of business logic, such as DB fetches and early
+         *   returns based on conditions.
+         * - Mark any incomplete or missing parts clearly with placeholders (e.g.,
+         *   comments or temporary values).
+         *
+         * ⚠️ Import rules:
+         *
+         * - Do NOT add any new import statements manually.
+         * - All necessary imports are provided globally or by the system
+         *   automatically.
+         * - Writing import statements directly is prohibited and may cause compile
+         *   errors. If import errors occur, check your environment configuration.
+         *
+         * ✅ Requirements:
+         *
+         * - Avoid using the `any` type at all costs to ensure type safety.
+         * - Do NOT assign native `Date` objects directly; always convert dates using
+         *   `.toISOString()` before assignment.
+         * - Maintain a single-function structure; avoid using classes.
+         */
+        /**
+         * 🔍 Phase 2: Review code
+         *
+         * A refined version of the draft with improved completeness.
+         *
+         * - Replace placeholder logic with real DTO-conformant operations.
+         * - Add error handling (`throw new Error(...)`) where necessary.
+         * - Begin resolving structural or type mismatches.
+         *
+         * ✅ Requirements:
+         *
+         * - Use `satisfies` to ensure DTO conformity.
+         * - Avoid unsafe `as` casts unless only for branding or literal narrowing.
+         * - Include `.toISOString()` for all date fields.
+         * - Ensure all object keys strictly conform to the expected type definitions.
+         */
+        review: string;
+        /**
+         * 🛠 Phase 3: With compiler feedback (optional)
+         *
+         * A correction pass that applies fixes for compile-time errors that arose
+         * during the review stage (if any).
+         *
+         * ✅ Must:
+         *
+         * - Resolve all TypeScript errors without using `as any`
+         * - Provide safe brand casting only if required (e.g., `as string &
+         *   tags.Format<'uuid'>`)
+         */
+        withCompilerFeedback?: string;
+        /**
+         * ✅ Phase 4: Final implementation
+         *
+         * The complete and fully correct TypeScript function implementation.
+         *
+         * - Passes strict type checking without errors.
+         * - Uses only safe branding or literal type assertions.
+         * - Converts all Date values properly to ISO string format.
+         * - Follows DTO structures using `satisfies`.
+         * - Avoids any weak typing such as `any`, `as any`, or `satisfies any`.
+         * - Uses only allowed imports (e.g., from `src/api/structures` and
+         *   `MyGlobal.prisma`).
+         *
+         * ⚠️ Prohibited Practices:
+         *
+         * - Do NOT add or modify import statements manually. Imports are handled
+         *   automatically by the system.
+         * - Do NOT use `any`, `as any`, or `satisfies any` to bypass type checking.
+         * - Do NOT assign native `Date` objects directly; always convert them to ISO
+         *   strings with `.toISOString()`.
+         * - Do NOT use unsafe type assertions except for safe branding or literal
+         *   narrowing.
+         * - Do NOT write code outside the single async function structure (e.g., no
+         *   classes or multiple functions).
+         * - Do NOT perform any input validation — assume all inputs are already
+         *   validated.
+         * - Do NOT use dynamic import expressions (`import()`); all imports must be
+         *   static.
+         * - Do NOT rely on DTO types for database update input; always use
+         *   Prisma-generated input types.
          */
         implementationCode: string;
     }

package/lib/orchestrate/realize/structures/IAutoBeRealizeCompile.d.ts

@@ -0,0 +1,23 @@
+import { AutoBeOpenApi, IAutoBeTypeScriptCompileResult } from "@autobe/interface";
+import { IAutoBeRealizeCoderApplication } from "./IAutoBeRealizeCoderApplication";
+import { FAILED } from "./IAutoBeRealizeFailedSymbol";
+export declare namespace IAutoBeRealizeCompile {
+    interface Success {
+        type: "success";
+        op: AutoBeOpenApi.IOperation;
+        result: Pick<IAutoBeRealizeCoderApplication.RealizeCoderOutput, "filename" | "implementationCode">;
+    }
+    interface Fail {
+        type: "failed";
+        op: AutoBeOpenApi.IOperation;
+        result: FAILED;
+    }
+    type FileContentMap = Record<string, {
+        content: string;
+        result: "failed" | "success";
+    }>;
+    interface CompileDiagnostics {
+        total: IAutoBeTypeScriptCompileResult.IDiagnostic[];
+        current: IAutoBeTypeScriptCompileResult.IDiagnostic[];
+    }
+}

package/lib/orchestrate/realize/structures/IAutoBeRealizeCompile.js

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

package/lib/orchestrate/realize/structures/IAutoBeRealizeCompile.js.map

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

package/lib/orchestrate/realize/structures/IAutoBeRealizeFailedSymbol.d.ts

@@ -0,0 +1,2 @@
+export declare const FAILED: unique symbol;
+export type FAILED = typeof FAILED;

package/lib/orchestrate/realize/structures/IAutoBeRealizeFailedSymbol.js

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

package/lib/orchestrate/realize/structures/IAutoBeRealizeFailedSymbol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IAutoBeRealizeFailedSymbol.js","sourceRoot":"","sources":["../../../../src/orchestrate/realize/structures/IAutoBeRealizeFailedSymbol.ts"],"names":[],"mappings":";;;AAAa,QAAA,MAAM,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC"}

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

@@ -1,5 +1,6 @@
 import { IAgenticaHistoryJson } from "@agentica/core";
+import { IAutoBeTypeScriptCompileResult } from "@autobe/interface";
 import { AutoBeState } from "../../context/AutoBeState";
 import { IAutoBeTestScenarioArtifacts } from "../test/structures/IAutoBeTestScenarioArtifacts";
 import { RealizePlannerOutput } from "./orchestrateRealizePlanner";
-export declare const transformRealizeCoderHistories: (state: AutoBeState, props: RealizePlannerOutput, artifacts: IAutoBeTestScenarioArtifacts) => Array<IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage>;
+export declare const transformRealizeCoderHistories: (state: AutoBeState, props: RealizePlannerOutput, artifacts: IAutoBeTestScenarioArtifacts, previous: string | null, total: IAutoBeTypeScriptCompileResult.IDiagnostic[], diagnostics: IAutoBeTypeScriptCompileResult.IDiagnostic[]) => Array<IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage>;