@autobe/agent 0.25.3 → 0.25.5

package/lib/index.mjs

@@ -467,7 +467,7 @@ function createController$q(props) {
     };
 }
 
-const claude$e = {
+const claude$b = {
     model: "claude",
     options: {
         reference: true,
@@ -628,10 +628,10 @@ const collection$s = {
             })()
         } ]
     },
-    claude: claude$e,
-    llama: claude$e,
-    deepseek: claude$e,
-    3.1: claude$e
+    claude: claude$b,
+    llama: claude$b,
+    deepseek: claude$b,
+    3.1: claude$b
 };
 
 function transformAnalyzeSceHistories(ctx, instruction) {
@@ -726,7 +726,7 @@ function createController$p(props) {
     };
 }
 
-const claude$d = {
+const claude$a = {
     model: "claude",
     options: {
         reference: true,
@@ -1355,10 +1355,10 @@ const collection$r = {
             })()
         } ]
     },
-    claude: claude$d,
-    llama: claude$d,
-    deepseek: claude$d,
-    3.1: claude$d
+    claude: claude$a,
+    llama: claude$a,
+    deepseek: claude$a,
+    3.1: claude$a
 };
 
 const orchestrateAnalyzeWrite = async (ctx, props) => {
@@ -1410,7 +1410,7 @@ function createController$o(props) {
     };
 }
 
-const claude$c = {
+const claude$9 = {
     model: "claude",
     options: {
         reference: true,
@@ -1555,10 +1555,10 @@ const collection$q = {
             })()
         } ]
     },
-    claude: claude$c,
-    llama: claude$c,
-    deepseek: claude$c,
-    3.1: claude$c
+    claude: claude$9,
+    llama: claude$9,
+    deepseek: claude$9,
+    3.1: claude$9
 };
 
 const orchestrateAnalyze = ctx => async props => {
@@ -8607,7 +8607,7 @@ function createController$l(props) {
     };
 }
 
-const claude$b = {
+const claude$8 = {
     model: "claude",
     options: {
         reference: true,
@@ -8854,10 +8854,10 @@ const collection$n = {
             })()
         } ]
     },
-    claude: claude$b,
-    llama: claude$b,
-    deepseek: claude$b,
-    3.1: claude$b
+    claude: claude$8,
+    llama: claude$8,
+    deepseek: claude$8,
+    3.1: claude$8
 };
 
 async function orchestrateInterfaceEndpoints(ctx, props) {
@@ -8931,7 +8931,7 @@ function createController$k(props) {
     };
 }
 
-const claude$a = {
+const claude$7 = {
     model: "claude",
     options: {
         reference: true,
@@ -9171,10 +9171,10 @@ const collection$m = {
             })()
         } ]
     },
-    claude: claude$a,
-    llama: claude$a,
-    deepseek: claude$a,
-    3.1: claude$a
+    claude: claude$7,
+    llama: claude$7,
+    deepseek: claude$7,
+    3.1: claude$7
 };
 
 const transformInterfaceCommonPrerequisiteHistories = state => {
@@ -9283,7 +9283,7 @@ function createController$j(props) {
     };
 }
 
-const claude$9 = {
+const claude$6 = {
     model: "claude",
     options: {
         reference: true,
@@ -9523,10 +9523,10 @@ const chatgpt = {
 
 const collection$l = {
     chatgpt,
-    claude: claude$9,
-    llama: claude$9,
-    deepseek: claude$9,
-    3.1: claude$9
+    claude: claude$6,
+    llama: claude$6,
+    deepseek: claude$6,
+    3.1: claude$6
 };
 
 function divideArray(props) {
@@ -21005,7 +21005,7 @@ function createController$e(props) {
     };
 }
 
-const claude$8 = {
+const claude$5 = {
     model: "claude",
     options: {
         reference: true,
@@ -21387,10 +21387,10 @@ const collection$f = {
             })()
         } ]
     },
-    claude: claude$8,
-    llama: claude$8,
-    deepseek: claude$8,
-    3.1: claude$8
+    claude: claude$5,
+    llama: claude$5,
+    deepseek: claude$5,
+    3.1: claude$5
 };
 
 const transformPrismaCorrectHistories = result => [ {
@@ -21430,7 +21430,7 @@ function orchestratePrismaCorrect(ctx, application) {
         return true;
     });
     application.files = application.files.filter(f => f.models.length !== 0);
-    return iterate(ctx, application, Math.max(ctx.retry, 5));
+    return iterate(ctx, application, Math.max(ctx.retry, 8));
 }
 
 async function iterate(ctx, application, life) {
@@ -21551,7 +21551,7 @@ const getTableCount = failure => {
     return unique.size;
 };
 
-const claude$7 = {
+const claude$4 = {
     model: "claude",
     options: {
         reference: true,
@@ -22650,10 +22650,10 @@ const collection$e = {
             })()
         } ]
     },
-    claude: claude$7,
-    llama: claude$7,
-    deepseek: claude$7,
-    3.1: claude$7
+    claude: claude$4,
+    llama: claude$4,
+    deepseek: claude$4,
+    3.1: claude$4
 };
 
 const transformPrismaReviewHistories = props => [ {
@@ -22783,7 +22783,7 @@ function createController$c(ctx, props) {
     };
 }
 
-const claude$6 = {
+const claude$3 = {
     model: "claude",
     options: {
         reference: true,
@@ -23898,10 +23898,10 @@ const collection$d = {
             })()
         } ]
     },
-    claude: claude$6,
-    llama: claude$6,
-    deepseek: claude$6,
-    3.1: claude$6
+    claude: claude$3,
+    llama: claude$3,
+    deepseek: claude$3,
+    3.1: claude$3
 };
 
 const transformPrismaSchemaHistories = props => [ {
@@ -25614,6 +25614,34 @@ async function compileRealizeFiles(ctx, props) {
     };
 }
 
+const validateEmptyCode = props => {
+    const errors = [];
+    if (props.draft.includes(props.functionName) === false) errors.push({
+        path: "$input.draft",
+        expected: `string (including function named '${props.functionName}')`,
+        value: props.draft,
+        description: description(props.functionName)
+    });
+    if (props.revise.final !== null && props.revise.final.includes(props.functionName) === false) errors.push({
+        path: "$input.revise.final",
+        expected: `string (including function named '${props.functionName}')`,
+        value: props.revise.final,
+        description: description(props.functionName)
+    });
+    return errors;
+};
+
+const description = func => StringUtil.trim`
+  The function ${func} does not exist in the provided code snippet.
+
+  The first reason of the non-existence is that the code snippet is empty,
+  and the second reason is that AI has written different function name
+  by mistake.
+
+  Please make sure that the code snippet includes the function ${func}.
+  Note that, you never have to write empty code or different function name.
+`;
+
 function printErrorHints(code, diagnostics) {
     const lines = code.split("\n");
     let cursor = 0;
@@ -25792,6 +25820,7 @@ const correct$4 = async (ctx, scenarios, authorizations, functions, failures, pr
             } ]),
             controller: createController$a({
                 model: ctx.model,
+                functionName: scenario.functionName,
                 then: next => {
                     pointer.value = next;
                 },
@@ -25932,7 +25961,81 @@ const filterRelevantDiagnostics = (diagnostics, functionLocations) => diagnostic
 
 const createController$a = props => {
     assertSchemaModel(props.model);
-    const application = collection$b[props.model === "chatgpt" ? "chatgpt" : "claude"];
+    const validate = input => {
+        const result = (() => {
+            const _io0 = input => "string" === typeof input.think && "string" === typeof input.draft && ("object" === typeof input.revise && null !== input.revise && _io1(input.revise));
+            const _io1 = input => "string" === typeof input.review && (null === input.final || "string" === typeof input.final);
+            const _vo0 = (input, _path, _exceptionable = true) => [ "string" === typeof input.think || _report(_exceptionable, {
+                path: _path + ".think",
+                expected: "string",
+                value: input.think
+            }), "string" === typeof input.draft || _report(_exceptionable, {
+                path: _path + ".draft",
+                expected: "string",
+                value: input.draft
+            }), ("object" === typeof input.revise && null !== input.revise || _report(_exceptionable, {
+                path: _path + ".revise",
+                expected: "IAutoBeCommonCorrectCastingApplication.IReviseProps",
+                value: input.revise
+            })) && _vo1(input.revise, _path + ".revise", _exceptionable) || _report(_exceptionable, {
+                path: _path + ".revise",
+                expected: "IAutoBeCommonCorrectCastingApplication.IReviseProps",
+                value: input.revise
+            }) ].every(flag => flag);
+            const _vo1 = (input, _path, _exceptionable = true) => [ "string" === typeof input.review || _report(_exceptionable, {
+                path: _path + ".review",
+                expected: "string",
+                value: input.review
+            }), null === input.final || "string" === typeof input.final || _report(_exceptionable, {
+                path: _path + ".final",
+                expected: "(null | string)",
+                value: input.final
+            }) ].every(flag => flag);
+            const __is = input => "object" === typeof input && null !== input && _io0(input);
+            let errors;
+            let _report;
+            return input => {
+                if (false === __is(input)) {
+                    errors = [];
+                    _report = __typia_transform__validateReport._validateReport(errors);
+                    ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
+                        path: _path + "",
+                        expected: "IAutoBeCommonCorrectCastingApplication.IProps",
+                        value: input
+                    })) && _vo0(input, _path + "", true) || _report(true, {
+                        path: _path + "",
+                        expected: "IAutoBeCommonCorrectCastingApplication.IProps",
+                        value: input
+                    }))(input, "$input", true);
+                    const success = 0 === errors.length;
+                    return success ? {
+                        success,
+                        data: input
+                    } : {
+                        success,
+                        errors,
+                        data: input
+                    };
+                }
+                return {
+                    success: true,
+                    data: input
+                };
+            };
+        })()(input);
+        if (result.success === false) return result;
+        const errors = validateEmptyCode({
+            functionName: props.functionName,
+            draft: result.data.draft,
+            revise: result.data.revise
+        });
+        return errors.length ? {
+            success: false,
+            errors,
+            data: result.data
+        } : result;
+    };
+    const application = collection$b[props.model === "chatgpt" ? "chatgpt" : "claude"](validate);
     return {
         protocol: "class",
         name: "correctInvalidRequest",
@@ -25949,258 +26052,288 @@ const createController$a = props => {
 };
 
 const collection$b = {
-    chatgpt: {
-        model: "chatgpt",
-        options: {
-            reference: true,
-            strict: false,
-            separate: null
-        },
-        functions: [ {
-            name: "rewrite",
-            parameters: {
-                description: " - The analysis and correction properties\n\n------------------------------\n\nCurrent Type: {@link IAutoBeCommonCorrectCastingApplication.IProps}\n\n### Description of {@link revise} property:\n\n> Review and finalization of type casting corrections.\n> \n> Contains the review of applied corrections and the final code with all\n> type casting issues resolved while preserving type safety and validation\n> intent.",
-                type: "object",
-                properties: {
-                    think: {
-                        description: "Initial analysis of the type casting or assignment error.\n\nContains the agent's analysis of the specific type mismatch pattern:\n\n- Type of casting error (tag incompatibility, nullable assignment, literal\n  type conversion, etc.)\n- Whether nullable or undefined types are involved\n- If Date to string conversions are needed\n- The chosen fix strategy for the specific error type",
-                        type: "string"
-                    },
-                    draft: {
-                        description: "Draft correction with initial type casting fixes.\n\nThe code after applying the first round of fixes:\n\n- Satisfies patterns for tag stripping\n- Date.toISOString() conversions where needed\n- Nullable type narrowing checks\n- Literal type assertions\n- Optional chaining result handling",
-                        type: "string"
+    chatgpt: validate => (() => {
+        const application = {
+            model: "chatgpt",
+            options: {
+                reference: true,
+                strict: false,
+                separate: null
+            },
+            functions: [ {
+                name: "rewrite",
+                parameters: {
+                    description: " - The analysis and correction properties\n\n------------------------------\n\nCurrent Type: {@link IAutoBeCommonCorrectCastingApplication.IProps}\n\n### Description of {@link revise} property:\n\n> Review and finalization of type casting corrections.\n> \n> Contains the review of applied corrections and the final code with all\n> type casting issues resolved while preserving type safety and validation\n> intent.",
+                    type: "object",
+                    properties: {
+                        think: {
+                            description: "Initial analysis of the type casting or assignment error.\n\nContains the agent's analysis of the specific type mismatch pattern:\n\n- Type of casting error (tag incompatibility, nullable assignment, literal\n  type conversion, etc.)\n- Whether nullable or undefined types are involved\n- If Date to string conversions are needed\n- The chosen fix strategy for the specific error type",
+                            type: "string"
+                        },
+                        draft: {
+                            description: "Draft correction with initial type casting fixes.\n\nThe code after applying the first round of fixes:\n\n- Satisfies patterns for tag stripping\n- Date.toISOString() conversions where needed\n- Nullable type narrowing checks\n- Literal type assertions\n- Optional chaining result handling",
+                            type: "string"
+                        },
+                        revise: {
+                            $ref: "#/$defs/IAutoBeCommonCorrectCastingApplication.IReviseProps"
+                        }
                     },
-                    revise: {
-                        $ref: "#/$defs/IAutoBeCommonCorrectCastingApplication.IReviseProps"
-                    }
-                },
-                required: [ "think", "draft", "revise" ],
-                additionalProperties: false,
-                $defs: {
-                    "IAutoBeCommonCorrectCastingApplication.IReviseProps": {
-                        type: "object",
-                        properties: {
-                            review: {
-                                description: "Review of the type casting correction patterns applied.\n\nExplains which correction strategies were used:\n\n- Which satisfies patterns were applied for tag issues\n- Where typia.assert or assertGuard was used\n- How Date conversions were handled\n- What nullable type narrowing was applied\n- How literal type conversions were resolved\n- Confirmation that all type casting issues are resolved",
-                                type: "string"
-                            },
-                            final: {
-                                description: "Final corrected code with all type casting issues resolved.\n\nThe complete code ready for TypeScript compilation, with all type casting\nand assignment errors properly fixed using appropriate patterns while\nmaintaining type safety and the original validation logic. When the draft\nalready successfully resolves all type casting issues with no problems\nfound during review, this value can be null, indicating no further\nrefinements are necessary.\n\nA `null` value signifies the draft corrections were already optimal and\nrequire no additional modifications.",
-                                anyOf: [ {
-                                    type: "null"
-                                }, {
+                    required: [ "think", "draft", "revise" ],
+                    additionalProperties: false,
+                    $defs: {
+                        "IAutoBeCommonCorrectCastingApplication.IReviseProps": {
+                            type: "object",
+                            properties: {
+                                review: {
+                                    description: "Review of the type casting correction patterns applied.\n\nExplains which correction strategies were used:\n\n- Which satisfies patterns were applied for tag issues\n- Where typia.assert or assertGuard was used\n- How Date conversions were handled\n- What nullable type narrowing was applied\n- How literal type conversions were resolved\n- Confirmation that all type casting issues are resolved",
                                     type: "string"
-                                } ]
-                            }
-                        },
-                        required: [ "review", "final" ]
+                                },
+                                final: {
+                                    description: "Final corrected code with all type casting issues resolved.\n\nThe complete code ready for TypeScript compilation, with all type casting\nand assignment errors properly fixed using appropriate patterns while\nmaintaining type safety and the original validation logic. When the draft\nalready successfully resolves all type casting issues with no problems\nfound during review, this value can be null, indicating no further\nrefinements are necessary.\n\nA `null` value signifies the draft corrections were already optimal and\nrequire no additional modifications.",
+                                    anyOf: [ {
+                                        type: "null"
+                                    }, {
+                                        type: "string"
+                                    } ]
+                                }
+                            },
+                            required: [ "review", "final" ]
+                        }
                     }
-                }
-            },
-            description: 'Rewrite function to fix type casting and assignment errors.\n\nThis function is called when the agent detects any type casting or\nassignment related compilation error patterns.\n\nThe agent applies various fix strategies based on the error type:\n\n- **Typia tag incompatibilities**: Uses `satisfies ... as ...` pattern to\n  strip incompatible tags, or `typia.assert<T>()` as a last resort\n- **Date conversions**: Uses `.toISOString()` method for Date to string\n  conversions\n- **Nullable type narrowing**: Applies exhaustive checks (e.g., !== null &&\n  !== undefined)\n- **typia.assert vs assertGuard**: Uses assert for value assignment,\n  assertGuard for type narrowing\n- **Literal type conversions**: Uses `typia.assert<T>()` for runtime\n  validation\n- **Optional chaining results**: Uses `=== true` or `??` operators\n- **"No overlap" errors**: Removes redundant comparisons',
-            validate: (() => {
-                const _io0 = input => "string" === typeof input.think && "string" === typeof input.draft && ("object" === typeof input.revise && null !== input.revise && _io1(input.revise));
-                const _io1 = input => "string" === typeof input.review && (null === input.final || "string" === typeof input.final);
-                const _vo0 = (input, _path, _exceptionable = true) => [ "string" === typeof input.think || _report(_exceptionable, {
-                    path: _path + ".think",
-                    expected: "string",
-                    value: input.think
-                }), "string" === typeof input.draft || _report(_exceptionable, {
-                    path: _path + ".draft",
-                    expected: "string",
-                    value: input.draft
-                }), ("object" === typeof input.revise && null !== input.revise || _report(_exceptionable, {
-                    path: _path + ".revise",
-                    expected: "IAutoBeCommonCorrectCastingApplication.IReviseProps",
-                    value: input.revise
-                })) && _vo1(input.revise, _path + ".revise", _exceptionable) || _report(_exceptionable, {
-                    path: _path + ".revise",
-                    expected: "IAutoBeCommonCorrectCastingApplication.IReviseProps",
-                    value: input.revise
-                }) ].every(flag => flag);
-                const _vo1 = (input, _path, _exceptionable = true) => [ "string" === typeof input.review || _report(_exceptionable, {
-                    path: _path + ".review",
-                    expected: "string",
-                    value: input.review
-                }), null === input.final || "string" === typeof input.final || _report(_exceptionable, {
-                    path: _path + ".final",
-                    expected: "(null | string)",
-                    value: input.final
-                }) ].every(flag => flag);
-                const __is = input => "object" === typeof input && null !== input && _io0(input);
-                let errors;
-                let _report;
-                return input => {
-                    if (false === __is(input)) {
-                        errors = [];
-                        _report = __typia_transform__validateReport._validateReport(errors);
-                        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
-                            path: _path + "",
-                            expected: "IAutoBeCommonCorrectCastingApplication.IProps",
-                            value: input
-                        })) && _vo0(input, _path + "", true) || _report(true, {
-                            path: _path + "",
-                            expected: "IAutoBeCommonCorrectCastingApplication.IProps",
-                            value: input
-                        }))(input, "$input", true);
-                        const success = 0 === errors.length;
-                        return success ? {
-                            success,
-                            data: input
-                        } : {
-                            success,
-                            errors,
+                },
+                description: 'Rewrite function to fix type casting and assignment errors.\n\nThis function is called when the agent detects any type casting or\nassignment related compilation error patterns.\n\nThe agent applies various fix strategies based on the error type:\n\n- **Typia tag incompatibilities**: Uses `satisfies ... as ...` pattern to\n  strip incompatible tags, or `typia.assert<T>()` as a last resort\n- **Date conversions**: Uses `.toISOString()` method for Date to string\n  conversions\n- **Nullable type narrowing**: Applies exhaustive checks (e.g., !== null &&\n  !== undefined)\n- **typia.assert vs assertGuard**: Uses assert for value assignment,\n  assertGuard for type narrowing\n- **Literal type conversions**: Uses `typia.assert<T>()` for runtime\n  validation\n- **Optional chaining results**: Uses `=== true` or `??` operators\n- **"No overlap" errors**: Removes redundant comparisons',
+                validate: (() => {
+                    const _io0 = input => "string" === typeof input.think && "string" === typeof input.draft && ("object" === typeof input.revise && null !== input.revise && _io1(input.revise));
+                    const _io1 = input => "string" === typeof input.review && (null === input.final || "string" === typeof input.final);
+                    const _vo0 = (input, _path, _exceptionable = true) => [ "string" === typeof input.think || _report(_exceptionable, {
+                        path: _path + ".think",
+                        expected: "string",
+                        value: input.think
+                    }), "string" === typeof input.draft || _report(_exceptionable, {
+                        path: _path + ".draft",
+                        expected: "string",
+                        value: input.draft
+                    }), ("object" === typeof input.revise && null !== input.revise || _report(_exceptionable, {
+                        path: _path + ".revise",
+                        expected: "IAutoBeCommonCorrectCastingApplication.IReviseProps",
+                        value: input.revise
+                    })) && _vo1(input.revise, _path + ".revise", _exceptionable) || _report(_exceptionable, {
+                        path: _path + ".revise",
+                        expected: "IAutoBeCommonCorrectCastingApplication.IReviseProps",
+                        value: input.revise
+                    }) ].every(flag => flag);
+                    const _vo1 = (input, _path, _exceptionable = true) => [ "string" === typeof input.review || _report(_exceptionable, {
+                        path: _path + ".review",
+                        expected: "string",
+                        value: input.review
+                    }), null === input.final || "string" === typeof input.final || _report(_exceptionable, {
+                        path: _path + ".final",
+                        expected: "(null | string)",
+                        value: input.final
+                    }) ].every(flag => flag);
+                    const __is = input => "object" === typeof input && null !== input && _io0(input);
+                    let errors;
+                    let _report;
+                    return input => {
+                        if (false === __is(input)) {
+                            errors = [];
+                            _report = __typia_transform__validateReport._validateReport(errors);
+                            ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
+                                path: _path + "",
+                                expected: "IAutoBeCommonCorrectCastingApplication.IProps",
+                                value: input
+                            })) && _vo0(input, _path + "", true) || _report(true, {
+                                path: _path + "",
+                                expected: "IAutoBeCommonCorrectCastingApplication.IProps",
+                                value: input
+                            }))(input, "$input", true);
+                            const success = 0 === errors.length;
+                            return success ? {
+                                success,
+                                data: input
+                            } : {
+                                success,
+                                errors,
+                                data: input
+                            };
+                        }
+                        return {
+                            success: true,
                             data: input
                         };
-                    }
-                    return {
-                        success: true,
-                        data: input
                     };
-                };
-            })()
-        }, {
-            name: "reject",
-            parameters: {
-                type: "object",
-                properties: {},
-                additionalProperties: false,
-                required: [],
-                $defs: {}
+                })()
+            }, {
+                name: "reject",
+                parameters: {
+                    type: "object",
+                    properties: {},
+                    additionalProperties: false,
+                    required: [],
+                    $defs: {}
+                },
+                description: "Reject function when error is not related to type casting or assignment.\n\nThis function is called when the compilation error is unrelated to type\ncasting issues (e.g., missing imports, syntax errors, undefined variables),\nindicating the error should be handled by a different agent.",
+                validate: (() => input => ({
+                    success: true,
+                    data: input
+                }))()
+            } ]
+        };
+        __typia_transform__llmApplicationFinalize._llmApplicationFinalize(application, {
+            ...{
+                validate: {
+                    rewrite: validate,
+                    reject: () => ({
+                        success: true,
+                        data: undefined
+                    })
+                }
             },
-            description: "Reject function when error is not related to type casting or assignment.\n\nThis function is called when the compilation error is unrelated to type\ncasting issues (e.g., missing imports, syntax errors, undefined variables),\nindicating the error should be handled by a different agent.",
-            validate: (() => input => ({
-                success: true,
-                data: input
-            }))()
-        } ]
-    },
-    claude: {
-        model: "claude",
-        options: {
-            reference: true,
-            separate: null
-        },
-        functions: [ {
-            name: "rewrite",
-            parameters: {
-                description: " - The analysis and correction properties\n\n------------------------------\n\nCurrent Type: {@link IAutoBeCommonCorrectCastingApplication.IProps}",
-                type: "object",
-                properties: {
-                    think: {
-                        description: "Initial analysis of the type casting or assignment error.\n\nContains the agent's analysis of the specific type mismatch pattern:\n\n- Type of casting error (tag incompatibility, nullable assignment, literal\n  type conversion, etc.)\n- Whether nullable or undefined types are involved\n- If Date to string conversions are needed\n- The chosen fix strategy for the specific error type",
-                        type: "string"
-                    },
-                    draft: {
-                        description: "Draft correction with initial type casting fixes.\n\nThe code after applying the first round of fixes:\n\n- Satisfies patterns for tag stripping\n- Date.toISOString() conversions where needed\n- Nullable type narrowing checks\n- Literal type assertions\n- Optional chaining result handling",
-                        type: "string"
+            equals: false
+        });
+        return application;
+    })(),
+    claude: validate => (() => {
+        const application = {
+            model: "claude",
+            options: {
+                reference: true,
+                separate: null
+            },
+            functions: [ {
+                name: "rewrite",
+                parameters: {
+                    description: " - The analysis and correction properties\n\n------------------------------\n\nCurrent Type: {@link IAutoBeCommonCorrectCastingApplication.IProps}",
+                    type: "object",
+                    properties: {
+                        think: {
+                            description: "Initial analysis of the type casting or assignment error.\n\nContains the agent's analysis of the specific type mismatch pattern:\n\n- Type of casting error (tag incompatibility, nullable assignment, literal\n  type conversion, etc.)\n- Whether nullable or undefined types are involved\n- If Date to string conversions are needed\n- The chosen fix strategy for the specific error type",
+                            type: "string"
+                        },
+                        draft: {
+                            description: "Draft correction with initial type casting fixes.\n\nThe code after applying the first round of fixes:\n\n- Satisfies patterns for tag stripping\n- Date.toISOString() conversions where needed\n- Nullable type narrowing checks\n- Literal type assertions\n- Optional chaining result handling",
+                            type: "string"
+                        },
+                        revise: {
+                            description: "Review and finalization of type casting corrections.\n\nContains the review of applied corrections and the final code with all\ntype casting issues resolved while preserving type safety and validation\nintent.",
+                            $ref: "#/$defs/IAutoBeCommonCorrectCastingApplication.IReviseProps"
+                        }
                     },
-                    revise: {
-                        description: "Review and finalization of type casting corrections.\n\nContains the review of applied corrections and the final code with all\ntype casting issues resolved while preserving type safety and validation\nintent.",
-                        $ref: "#/$defs/IAutoBeCommonCorrectCastingApplication.IReviseProps"
-                    }
-                },
-                required: [ "think", "draft", "revise" ],
-                additionalProperties: false,
-                $defs: {
-                    "IAutoBeCommonCorrectCastingApplication.IReviseProps": {
-                        type: "object",
-                        properties: {
-                            review: {
-                                description: "Review of the type casting correction patterns applied.\n\nExplains which correction strategies were used:\n\n- Which satisfies patterns were applied for tag issues\n- Where typia.assert or assertGuard was used\n- How Date conversions were handled\n- What nullable type narrowing was applied\n- How literal type conversions were resolved\n- Confirmation that all type casting issues are resolved",
-                                type: "string"
-                            },
-                            final: {
-                                description: "Final corrected code with all type casting issues resolved.\n\nThe complete code ready for TypeScript compilation, with all type casting\nand assignment errors properly fixed using appropriate patterns while\nmaintaining type safety and the original validation logic. When the draft\nalready successfully resolves all type casting issues with no problems\nfound during review, this value can be null, indicating no further\nrefinements are necessary.\n\nA `null` value signifies the draft corrections were already optimal and\nrequire no additional modifications.",
-                                oneOf: [ {
-                                    type: "null"
-                                }, {
+                    required: [ "think", "draft", "revise" ],
+                    additionalProperties: false,
+                    $defs: {
+                        "IAutoBeCommonCorrectCastingApplication.IReviseProps": {
+                            type: "object",
+                            properties: {
+                                review: {
+                                    description: "Review of the type casting correction patterns applied.\n\nExplains which correction strategies were used:\n\n- Which satisfies patterns were applied for tag issues\n- Where typia.assert or assertGuard was used\n- How Date conversions were handled\n- What nullable type narrowing was applied\n- How literal type conversions were resolved\n- Confirmation that all type casting issues are resolved",
                                     type: "string"
-                                } ]
-                            }
-                        },
-                        required: [ "review", "final" ]
+                                },
+                                final: {
+                                    description: "Final corrected code with all type casting issues resolved.\n\nThe complete code ready for TypeScript compilation, with all type casting\nand assignment errors properly fixed using appropriate patterns while\nmaintaining type safety and the original validation logic. When the draft\nalready successfully resolves all type casting issues with no problems\nfound during review, this value can be null, indicating no further\nrefinements are necessary.\n\nA `null` value signifies the draft corrections were already optimal and\nrequire no additional modifications.",
+                                    oneOf: [ {
+                                        type: "null"
+                                    }, {
+                                        type: "string"
+                                    } ]
+                                }
+                            },
+                            required: [ "review", "final" ]
+                        }
                     }
-                }
-            },
-            description: 'Rewrite function to fix type casting and assignment errors.\n\nThis function is called when the agent detects any type casting or\nassignment related compilation error patterns.\n\nThe agent applies various fix strategies based on the error type:\n\n- **Typia tag incompatibilities**: Uses `satisfies ... as ...` pattern to\n  strip incompatible tags, or `typia.assert<T>()` as a last resort\n- **Date conversions**: Uses `.toISOString()` method for Date to string\n  conversions\n- **Nullable type narrowing**: Applies exhaustive checks (e.g., !== null &&\n  !== undefined)\n- **typia.assert vs assertGuard**: Uses assert for value assignment,\n  assertGuard for type narrowing\n- **Literal type conversions**: Uses `typia.assert<T>()` for runtime\n  validation\n- **Optional chaining results**: Uses `=== true` or `??` operators\n- **"No overlap" errors**: Removes redundant comparisons',
-            validate: (() => {
-                const _io0 = input => "string" === typeof input.think && "string" === typeof input.draft && ("object" === typeof input.revise && null !== input.revise && _io1(input.revise));
-                const _io1 = input => "string" === typeof input.review && (null === input.final || "string" === typeof input.final);
-                const _vo0 = (input, _path, _exceptionable = true) => [ "string" === typeof input.think || _report(_exceptionable, {
-                    path: _path + ".think",
-                    expected: "string",
-                    value: input.think
-                }), "string" === typeof input.draft || _report(_exceptionable, {
-                    path: _path + ".draft",
-                    expected: "string",
-                    value: input.draft
-                }), ("object" === typeof input.revise && null !== input.revise || _report(_exceptionable, {
-                    path: _path + ".revise",
-                    expected: "IAutoBeCommonCorrectCastingApplication.IReviseProps",
-                    value: input.revise
-                })) && _vo1(input.revise, _path + ".revise", _exceptionable) || _report(_exceptionable, {
-                    path: _path + ".revise",
-                    expected: "IAutoBeCommonCorrectCastingApplication.IReviseProps",
-                    value: input.revise
-                }) ].every(flag => flag);
-                const _vo1 = (input, _path, _exceptionable = true) => [ "string" === typeof input.review || _report(_exceptionable, {
-                    path: _path + ".review",
-                    expected: "string",
-                    value: input.review
-                }), null === input.final || "string" === typeof input.final || _report(_exceptionable, {
-                    path: _path + ".final",
-                    expected: "(null | string)",
-                    value: input.final
-                }) ].every(flag => flag);
-                const __is = input => "object" === typeof input && null !== input && _io0(input);
-                let errors;
-                let _report;
-                return input => {
-                    if (false === __is(input)) {
-                        errors = [];
-                        _report = __typia_transform__validateReport._validateReport(errors);
-                        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
-                            path: _path + "",
-                            expected: "IAutoBeCommonCorrectCastingApplication.IProps",
-                            value: input
-                        })) && _vo0(input, _path + "", true) || _report(true, {
-                            path: _path + "",
-                            expected: "IAutoBeCommonCorrectCastingApplication.IProps",
-                            value: input
-                        }))(input, "$input", true);
-                        const success = 0 === errors.length;
-                        return success ? {
-                            success,
-                            data: input
-                        } : {
-                            success,
-                            errors,
+                },
+                description: 'Rewrite function to fix type casting and assignment errors.\n\nThis function is called when the agent detects any type casting or\nassignment related compilation error patterns.\n\nThe agent applies various fix strategies based on the error type:\n\n- **Typia tag incompatibilities**: Uses `satisfies ... as ...` pattern to\n  strip incompatible tags, or `typia.assert<T>()` as a last resort\n- **Date conversions**: Uses `.toISOString()` method for Date to string\n  conversions\n- **Nullable type narrowing**: Applies exhaustive checks (e.g., !== null &&\n  !== undefined)\n- **typia.assert vs assertGuard**: Uses assert for value assignment,\n  assertGuard for type narrowing\n- **Literal type conversions**: Uses `typia.assert<T>()` for runtime\n  validation\n- **Optional chaining results**: Uses `=== true` or `??` operators\n- **"No overlap" errors**: Removes redundant comparisons',
+                validate: (() => {
+                    const _io0 = input => "string" === typeof input.think && "string" === typeof input.draft && ("object" === typeof input.revise && null !== input.revise && _io1(input.revise));
+                    const _io1 = input => "string" === typeof input.review && (null === input.final || "string" === typeof input.final);
+                    const _vo0 = (input, _path, _exceptionable = true) => [ "string" === typeof input.think || _report(_exceptionable, {
+                        path: _path + ".think",
+                        expected: "string",
+                        value: input.think
+                    }), "string" === typeof input.draft || _report(_exceptionable, {
+                        path: _path + ".draft",
+                        expected: "string",
+                        value: input.draft
+                    }), ("object" === typeof input.revise && null !== input.revise || _report(_exceptionable, {
+                        path: _path + ".revise",
+                        expected: "IAutoBeCommonCorrectCastingApplication.IReviseProps",
+                        value: input.revise
+                    })) && _vo1(input.revise, _path + ".revise", _exceptionable) || _report(_exceptionable, {
+                        path: _path + ".revise",
+                        expected: "IAutoBeCommonCorrectCastingApplication.IReviseProps",
+                        value: input.revise
+                    }) ].every(flag => flag);
+                    const _vo1 = (input, _path, _exceptionable = true) => [ "string" === typeof input.review || _report(_exceptionable, {
+                        path: _path + ".review",
+                        expected: "string",
+                        value: input.review
+                    }), null === input.final || "string" === typeof input.final || _report(_exceptionable, {
+                        path: _path + ".final",
+                        expected: "(null | string)",
+                        value: input.final
+                    }) ].every(flag => flag);
+                    const __is = input => "object" === typeof input && null !== input && _io0(input);
+                    let errors;
+                    let _report;
+                    return input => {
+                        if (false === __is(input)) {
+                            errors = [];
+                            _report = __typia_transform__validateReport._validateReport(errors);
+                            ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
+                                path: _path + "",
+                                expected: "IAutoBeCommonCorrectCastingApplication.IProps",
+                                value: input
+                            })) && _vo0(input, _path + "", true) || _report(true, {
+                                path: _path + "",
+                                expected: "IAutoBeCommonCorrectCastingApplication.IProps",
+                                value: input
+                            }))(input, "$input", true);
+                            const success = 0 === errors.length;
+                            return success ? {
+                                success,
+                                data: input
+                            } : {
+                                success,
+                                errors,
+                                data: input
+                            };
+                        }
+                        return {
+                            success: true,
                             data: input
                         };
-                    }
-                    return {
-                        success: true,
-                        data: input
                     };
-                };
-            })()
-        }, {
-            name: "reject",
-            parameters: {
-                type: "object",
-                properties: {},
-                additionalProperties: false,
-                required: [],
-                $defs: {}
+                })()
+            }, {
+                name: "reject",
+                parameters: {
+                    type: "object",
+                    properties: {},
+                    additionalProperties: false,
+                    required: [],
+                    $defs: {}
+                },
+                description: "Reject function when error is not related to type casting or assignment.\n\nThis function is called when the compilation error is unrelated to type\ncasting issues (e.g., missing imports, syntax errors, undefined variables),\nindicating the error should be handled by a different agent.",
+                validate: (() => input => ({
+                    success: true,
+                    data: input
+                }))()
+            } ]
+        };
+        __typia_transform__llmApplicationFinalize._llmApplicationFinalize(application, {
+            ...{
+                validate: {
+                    rewrite: validate,
+                    reject: () => ({
+                        success: true,
+                        data: undefined
+                    })
+                }
             },
-            description: "Reject function when error is not related to type casting or assignment.\n\nThis function is called when the compilation error is unrelated to type\ncasting issues (e.g., missing imports, syntax errors, undefined variables),\nindicating the error should be handled by a different agent.",
-            validate: (() => input => ({
-                success: true,
-                data: input
-            }))()
-        } ]
-    }
+            equals: false
+        });
+        return application;
+    })()
 };
 
 const transformRealizeAuthorizationHistories = (ctx, role) => [ {
@@ -26429,7 +26562,7 @@ function createController$9(props) {
     };
 }
 
-const claude$5 = {
+const claude$2 = {
     model: "claude",
     options: {
         reference: true,
@@ -26816,10 +26949,10 @@ const collection$a = {
             })()
         } ]
     },
-    claude: claude$5,
-    llama: claude$5,
-    deepseek: claude$5,
-    3.1: claude$5
+    claude: claude$2,
+    llama: claude$2,
+    deepseek: claude$2,
+    3.1: claude$2
 };
 
 var InternalFileSystem;
@@ -26922,7 +27055,7 @@ function createController$8(props) {
     };
 }
 
-const claude$4 = {
+const claude$1 = {
     model: "claude",
     options: {
         reference: true,
@@ -27277,10 +27410,10 @@ const collection$9 = {
             })()
         } ]
     },
-    claude: claude$4,
-    llama: claude$4,
-    deepseek: claude$4,
-    3.1: claude$4
+    claude: claude$1,
+    llama: claude$1,
+    deepseek: claude$1,
+    3.1: claude$1
 };
 
 function getRealizeWriteInputType(operation, authorization) {
@@ -27759,7 +27892,7 @@ async function orchestrateRealizeCorrect(ctx, scenarios, authorizations, functio
         if (!location.startsWith("src/providers")) return;
         if (!diagnosticsByFile[location]) {
             const func = functions.find(f => f.location === location);
-            if (!func) {
+            if (func === undefined) {
                 return;
             }
             const failure = {
@@ -27819,6 +27952,7 @@ async function step(ctx, props) {
         source: "realizeCorrect",
         controller: createController$7({
             model: ctx.model,
+            functionName: props.scenario.functionName,
             build: next => {
                 pointer.value = next;
             }
@@ -27886,69 +28020,8 @@ async function step(ctx, props) {
 
 function createController$7(props) {
     assertSchemaModel(props.model);
-    const application = collection$8[props.model];
-    return {
-        protocol: "class",
-        name: "Write code",
-        application,
-        execute: {
-            correct: next => {
-                props.build(next);
-            }
-        }
-    };
-}
-
-const claude$3 = {
-    model: "claude",
-    options: {
-        reference: true,
-        separate: null
-    },
-    functions: [ {
-        name: "correct",
-        parameters: {
-            description: " Three-phase correction properties\n\n------------------------------\n\nCurrent Type: {@link IAutoBeRealizeCorrectApplication.IProps}",
-            type: "object",
-            properties: {
-                think: {
-                    description: "Initial error analysis and correction strategy.\n\nAnalyzes TypeScript compilation errors to understand:\n\n- Error patterns and root causes\n- Required fixes and their impact\n- Whether quick fixes or deep refactoring is needed\n- Prisma schema and API contract constraints",
-                    type: "string"
-                },
-                draft: {
-                    description: "First correction attempt.\n\nImplements the initial fixes identified in the think phase. For simple\nerrors (typos, missing imports), this may be the final solution. Complex\nerrors may require further refinement.",
-                    type: "string"
-                },
-                revise: {
-                    description: "Revision and finalization phase.\n\nReviews the draft corrections and produces the final, error-free code\nthat maintains all business requirements.",
-                    $ref: "#/$defs/IAutoBeRealizeCorrectApplication.IReviseProps"
-                }
-            },
-            required: [ "think", "draft", "revise" ],
-            additionalProperties: false,
-            $defs: {
-                "IAutoBeRealizeCorrectApplication.IReviseProps": {
-                    type: "object",
-                    properties: {
-                        review: {
-                            description: "Correction review and validation.\n\nAnalyzes the draft corrections to ensure:\n\n- All TypeScript errors are resolved\n- Business logic remains intact\n- AutoBE coding standards are maintained\n- No new errors are introduced\n- Performance and security are preserved",
-                            type: "string"
-                        },
-                        final: {
-                            description: "Final error-free implementation.\n\nThe complete, corrected code that passes all TypeScript compilation\nchecks.\n\nReturns `null` if the draft corrections are sufficient and need no\nfurther changes.",
-                            oneOf: [ {
-                                type: "null"
-                            }, {
-                                type: "string"
-                            } ]
-                        }
-                    },
-                    required: [ "review", "final" ]
-                }
-            }
-        },
-        description: "Systematically analyze and correct TypeScript compilation errors.\n\nImplements a three-phase workflow (think → draft → revise) that balances\nefficiency for simple errors with thoroughness for complex problems.",
-        validate: (() => {
+    const validate = input => {
+        const result = (() => {
             const _io0 = input => "string" === typeof input.think && "string" === typeof input.draft && ("object" === typeof input.revise && null !== input.revise && _io1(input.revise));
             const _io1 = input => "string" === typeof input.review && (null === input.final || "string" === typeof input.final);
             const _vo0 = (input, _path, _exceptionable = true) => [ "string" === typeof input.think || _report(_exceptionable, {
@@ -28008,127 +28081,279 @@ const claude$3 = {
                     data: input
                 };
             };
-        })()
-    } ]
-};
+        })()(input);
+        if (result.success === false) return result;
+        const errors = validateEmptyCode({
+            functionName: props.functionName,
+            draft: result.data.draft,
+            revise: result.data.revise
+        });
+        return errors.length ? {
+            success: false,
+            errors,
+            data: result.data
+        } : result;
+    };
+    const application = collection$8[props.model === "chatgpt" ? "chatgpt" : "claude"](validate);
+    return {
+        protocol: "class",
+        name: "Write code",
+        application,
+        execute: {
+            correct: next => {
+                props.build(next);
+            }
+        }
+    };
+}
 
 const collection$8 = {
-    chatgpt: {
-        model: "chatgpt",
-        options: {
-            reference: true,
-            strict: false,
-            separate: null
-        },
-        functions: [ {
-            name: "correct",
-            parameters: {
-                description: " Three-phase correction properties\n\n------------------------------\n\nCurrent Type: {@link IAutoBeRealizeCorrectApplication.IProps}\n\n### Description of {@link revise} property:\n\n> Revision and finalization phase.\n> \n> Reviews the draft corrections and produces the final, error-free code\n> that maintains all business requirements.",
-                type: "object",
-                properties: {
-                    think: {
-                        description: "Initial error analysis and correction strategy.\n\nAnalyzes TypeScript compilation errors to understand:\n\n- Error patterns and root causes\n- Required fixes and their impact\n- Whether quick fixes or deep refactoring is needed\n- Prisma schema and API contract constraints",
-                        type: "string"
-                    },
-                    draft: {
-                        description: "First correction attempt.\n\nImplements the initial fixes identified in the think phase. For simple\nerrors (typos, missing imports), this may be the final solution. Complex\nerrors may require further refinement.",
-                        type: "string"
+    chatgpt: validate => (() => {
+        const application = {
+            model: "chatgpt",
+            options: {
+                reference: true,
+                strict: false,
+                separate: null
+            },
+            functions: [ {
+                name: "correct",
+                parameters: {
+                    description: " Three-phase correction properties\n\n------------------------------\n\nCurrent Type: {@link IAutoBeRealizeCorrectApplication.IProps}\n\n### Description of {@link revise} property:\n\n> Revision and finalization phase.\n> \n> Reviews the draft corrections and produces the final, error-free code\n> that maintains all business requirements.",
+                    type: "object",
+                    properties: {
+                        think: {
+                            description: "Initial error analysis and correction strategy.\n\nAnalyzes TypeScript compilation errors to understand:\n\n- Error patterns and root causes\n- Required fixes and their impact\n- Whether quick fixes or deep refactoring is needed\n- Prisma schema and API contract constraints",
+                            type: "string"
+                        },
+                        draft: {
+                            description: "First correction attempt.\n\nImplements the initial fixes identified in the think phase. For simple\nerrors (typos, missing imports), this may be the final solution. Complex\nerrors may require further refinement.",
+                            type: "string"
+                        },
+                        revise: {
+                            $ref: "#/$defs/IAutoBeRealizeCorrectApplication.IReviseProps"
+                        }
                     },
-                    revise: {
-                        $ref: "#/$defs/IAutoBeRealizeCorrectApplication.IReviseProps"
-                    }
-                },
-                required: [ "think", "draft", "revise" ],
-                additionalProperties: false,
-                $defs: {
-                    "IAutoBeRealizeCorrectApplication.IReviseProps": {
-                        type: "object",
-                        properties: {
-                            review: {
-                                description: "Correction review and validation.\n\nAnalyzes the draft corrections to ensure:\n\n- All TypeScript errors are resolved\n- Business logic remains intact\n- AutoBE coding standards are maintained\n- No new errors are introduced\n- Performance and security are preserved",
-                                type: "string"
-                            },
-                            final: {
-                                description: "Final error-free implementation.\n\nThe complete, corrected code that passes all TypeScript compilation\nchecks.\n\nReturns `null` if the draft corrections are sufficient and need no\nfurther changes.",
-                                anyOf: [ {
-                                    type: "null"
-                                }, {
+                    required: [ "think", "draft", "revise" ],
+                    additionalProperties: false,
+                    $defs: {
+                        "IAutoBeRealizeCorrectApplication.IReviseProps": {
+                            type: "object",
+                            properties: {
+                                review: {
+                                    description: "Correction review and validation.\n\nAnalyzes the draft corrections to ensure:\n\n- All TypeScript errors are resolved\n- Business logic remains intact\n- AutoBE coding standards are maintained\n- No new errors are introduced\n- Performance and security are preserved",
                                     type: "string"
-                                } ]
-                            }
-                        },
-                        required: [ "review", "final" ]
+                                },
+                                final: {
+                                    description: "Final error-free implementation.\n\nThe complete, corrected code that passes all TypeScript compilation\nchecks.\n\nReturns `null` if the draft corrections are sufficient and need no\nfurther changes.",
+                                    anyOf: [ {
+                                        type: "null"
+                                    }, {
+                                        type: "string"
+                                    } ]
+                                }
+                            },
+                            required: [ "review", "final" ]
+                        }
                     }
+                },
+                description: "Systematically analyze and correct TypeScript compilation errors.\n\nImplements a three-phase workflow (think → draft → revise) that balances\nefficiency for simple errors with thoroughness for complex problems.",
+                validate: (() => {
+                    const _io0 = input => "string" === typeof input.think && "string" === typeof input.draft && ("object" === typeof input.revise && null !== input.revise && _io1(input.revise));
+                    const _io1 = input => "string" === typeof input.review && (null === input.final || "string" === typeof input.final);
+                    const _vo0 = (input, _path, _exceptionable = true) => [ "string" === typeof input.think || _report(_exceptionable, {
+                        path: _path + ".think",
+                        expected: "string",
+                        value: input.think
+                    }), "string" === typeof input.draft || _report(_exceptionable, {
+                        path: _path + ".draft",
+                        expected: "string",
+                        value: input.draft
+                    }), ("object" === typeof input.revise && null !== input.revise || _report(_exceptionable, {
+                        path: _path + ".revise",
+                        expected: "IAutoBeRealizeCorrectApplication.IReviseProps",
+                        value: input.revise
+                    })) && _vo1(input.revise, _path + ".revise", _exceptionable) || _report(_exceptionable, {
+                        path: _path + ".revise",
+                        expected: "IAutoBeRealizeCorrectApplication.IReviseProps",
+                        value: input.revise
+                    }) ].every(flag => flag);
+                    const _vo1 = (input, _path, _exceptionable = true) => [ "string" === typeof input.review || _report(_exceptionable, {
+                        path: _path + ".review",
+                        expected: "string",
+                        value: input.review
+                    }), null === input.final || "string" === typeof input.final || _report(_exceptionable, {
+                        path: _path + ".final",
+                        expected: "(null | string)",
+                        value: input.final
+                    }) ].every(flag => flag);
+                    const __is = input => "object" === typeof input && null !== input && _io0(input);
+                    let errors;
+                    let _report;
+                    return input => {
+                        if (false === __is(input)) {
+                            errors = [];
+                            _report = __typia_transform__validateReport._validateReport(errors);
+                            ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
+                                path: _path + "",
+                                expected: "IAutoBeRealizeCorrectApplication.IProps",
+                                value: input
+                            })) && _vo0(input, _path + "", true) || _report(true, {
+                                path: _path + "",
+                                expected: "IAutoBeRealizeCorrectApplication.IProps",
+                                value: input
+                            }))(input, "$input", true);
+                            const success = 0 === errors.length;
+                            return success ? {
+                                success,
+                                data: input
+                            } : {
+                                success,
+                                errors,
+                                data: input
+                            };
+                        }
+                        return {
+                            success: true,
+                            data: input
+                        };
+                    };
+                })()
+            } ]
+        };
+        __typia_transform__llmApplicationFinalize._llmApplicationFinalize(application, {
+            ...{
+                validate: {
+                    correct: validate
                 }
             },
-            description: "Systematically analyze and correct TypeScript compilation errors.\n\nImplements a three-phase workflow (think → draft → revise) that balances\nefficiency for simple errors with thoroughness for complex problems.",
-            validate: (() => {
-                const _io0 = input => "string" === typeof input.think && "string" === typeof input.draft && ("object" === typeof input.revise && null !== input.revise && _io1(input.revise));
-                const _io1 = input => "string" === typeof input.review && (null === input.final || "string" === typeof input.final);
-                const _vo0 = (input, _path, _exceptionable = true) => [ "string" === typeof input.think || _report(_exceptionable, {
-                    path: _path + ".think",
-                    expected: "string",
-                    value: input.think
-                }), "string" === typeof input.draft || _report(_exceptionable, {
-                    path: _path + ".draft",
-                    expected: "string",
-                    value: input.draft
-                }), ("object" === typeof input.revise && null !== input.revise || _report(_exceptionable, {
-                    path: _path + ".revise",
-                    expected: "IAutoBeRealizeCorrectApplication.IReviseProps",
-                    value: input.revise
-                })) && _vo1(input.revise, _path + ".revise", _exceptionable) || _report(_exceptionable, {
-                    path: _path + ".revise",
-                    expected: "IAutoBeRealizeCorrectApplication.IReviseProps",
-                    value: input.revise
-                }) ].every(flag => flag);
-                const _vo1 = (input, _path, _exceptionable = true) => [ "string" === typeof input.review || _report(_exceptionable, {
-                    path: _path + ".review",
-                    expected: "string",
-                    value: input.review
-                }), null === input.final || "string" === typeof input.final || _report(_exceptionable, {
-                    path: _path + ".final",
-                    expected: "(null | string)",
-                    value: input.final
-                }) ].every(flag => flag);
-                const __is = input => "object" === typeof input && null !== input && _io0(input);
-                let errors;
-                let _report;
-                return input => {
-                    if (false === __is(input)) {
-                        errors = [];
-                        _report = __typia_transform__validateReport._validateReport(errors);
-                        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
-                            path: _path + "",
-                            expected: "IAutoBeRealizeCorrectApplication.IProps",
-                            value: input
-                        })) && _vo0(input, _path + "", true) || _report(true, {
-                            path: _path + "",
-                            expected: "IAutoBeRealizeCorrectApplication.IProps",
-                            value: input
-                        }))(input, "$input", true);
-                        const success = 0 === errors.length;
-                        return success ? {
-                            success,
-                            data: input
-                        } : {
-                            success,
-                            errors,
+            equals: false
+        });
+        return application;
+    })(),
+    claude: validate => (() => {
+        const application = {
+            model: "claude",
+            options: {
+                reference: true,
+                separate: null
+            },
+            functions: [ {
+                name: "correct",
+                parameters: {
+                    description: " Three-phase correction properties\n\n------------------------------\n\nCurrent Type: {@link IAutoBeRealizeCorrectApplication.IProps}",
+                    type: "object",
+                    properties: {
+                        think: {
+                            description: "Initial error analysis and correction strategy.\n\nAnalyzes TypeScript compilation errors to understand:\n\n- Error patterns and root causes\n- Required fixes and their impact\n- Whether quick fixes or deep refactoring is needed\n- Prisma schema and API contract constraints",
+                            type: "string"
+                        },
+                        draft: {
+                            description: "First correction attempt.\n\nImplements the initial fixes identified in the think phase. For simple\nerrors (typos, missing imports), this may be the final solution. Complex\nerrors may require further refinement.",
+                            type: "string"
+                        },
+                        revise: {
+                            description: "Revision and finalization phase.\n\nReviews the draft corrections and produces the final, error-free code\nthat maintains all business requirements.",
+                            $ref: "#/$defs/IAutoBeRealizeCorrectApplication.IReviseProps"
+                        }
+                    },
+                    required: [ "think", "draft", "revise" ],
+                    additionalProperties: false,
+                    $defs: {
+                        "IAutoBeRealizeCorrectApplication.IReviseProps": {
+                            type: "object",
+                            properties: {
+                                review: {
+                                    description: "Correction review and validation.\n\nAnalyzes the draft corrections to ensure:\n\n- All TypeScript errors are resolved\n- Business logic remains intact\n- AutoBE coding standards are maintained\n- No new errors are introduced\n- Performance and security are preserved",
+                                    type: "string"
+                                },
+                                final: {
+                                    description: "Final error-free implementation.\n\nThe complete, corrected code that passes all TypeScript compilation\nchecks.\n\nReturns `null` if the draft corrections are sufficient and need no\nfurther changes.",
+                                    oneOf: [ {
+                                        type: "null"
+                                    }, {
+                                        type: "string"
+                                    } ]
+                                }
+                            },
+                            required: [ "review", "final" ]
+                        }
+                    }
+                },
+                description: "Systematically analyze and correct TypeScript compilation errors.\n\nImplements a three-phase workflow (think → draft → revise) that balances\nefficiency for simple errors with thoroughness for complex problems.",
+                validate: (() => {
+                    const _io0 = input => "string" === typeof input.think && "string" === typeof input.draft && ("object" === typeof input.revise && null !== input.revise && _io1(input.revise));
+                    const _io1 = input => "string" === typeof input.review && (null === input.final || "string" === typeof input.final);
+                    const _vo0 = (input, _path, _exceptionable = true) => [ "string" === typeof input.think || _report(_exceptionable, {
+                        path: _path + ".think",
+                        expected: "string",
+                        value: input.think
+                    }), "string" === typeof input.draft || _report(_exceptionable, {
+                        path: _path + ".draft",
+                        expected: "string",
+                        value: input.draft
+                    }), ("object" === typeof input.revise && null !== input.revise || _report(_exceptionable, {
+                        path: _path + ".revise",
+                        expected: "IAutoBeRealizeCorrectApplication.IReviseProps",
+                        value: input.revise
+                    })) && _vo1(input.revise, _path + ".revise", _exceptionable) || _report(_exceptionable, {
+                        path: _path + ".revise",
+                        expected: "IAutoBeRealizeCorrectApplication.IReviseProps",
+                        value: input.revise
+                    }) ].every(flag => flag);
+                    const _vo1 = (input, _path, _exceptionable = true) => [ "string" === typeof input.review || _report(_exceptionable, {
+                        path: _path + ".review",
+                        expected: "string",
+                        value: input.review
+                    }), null === input.final || "string" === typeof input.final || _report(_exceptionable, {
+                        path: _path + ".final",
+                        expected: "(null | string)",
+                        value: input.final
+                    }) ].every(flag => flag);
+                    const __is = input => "object" === typeof input && null !== input && _io0(input);
+                    let errors;
+                    let _report;
+                    return input => {
+                        if (false === __is(input)) {
+                            errors = [];
+                            _report = __typia_transform__validateReport._validateReport(errors);
+                            ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
+                                path: _path + "",
+                                expected: "IAutoBeRealizeCorrectApplication.IProps",
+                                value: input
+                            })) && _vo0(input, _path + "", true) || _report(true, {
+                                path: _path + "",
+                                expected: "IAutoBeRealizeCorrectApplication.IProps",
+                                value: input
+                            }))(input, "$input", true);
+                            const success = 0 === errors.length;
+                            return success ? {
+                                success,
+                                data: input
+                            } : {
+                                success,
+                                errors,
+                                data: input
+                            };
+                        }
+                        return {
+                            success: true,
                             data: input
                         };
-                    }
-                    return {
-                        success: true,
-                        data: input
                     };
-                };
-            })()
-        } ]
-    },
-    claude: claude$3,
-    llama: claude$3,
-    deepseek: claude$3,
-    3.1: claude$3
+                })()
+            } ]
+        };
+        __typia_transform__llmApplicationFinalize._llmApplicationFinalize(application, {
+            ...{
+                validate: {
+                    correct: validate
+                }
+            },
+            equals: false
+        });
+        return application;
+    })()
 };
 
 async function orchestrateRealizeWrite(ctx, props) {
@@ -28147,6 +28372,7 @@ async function orchestrateRealizeWrite(ctx, props) {
         }),
         controller: createController$6({
             model: ctx.model,
+            functionName: props.scenario.functionName,
             build: next => {
                 pointer.value = next;
             }
@@ -28201,69 +28427,8 @@ async function orchestrateRealizeWrite(ctx, props) {
 
 function createController$6(props) {
     assertSchemaModel(props.model);
-    const application = collection$7[props.model];
-    return {
-        protocol: "class",
-        name: "Write code",
-        application,
-        execute: {
-            write: next => {
-                props.build(next);
-            }
-        }
-    };
-}
-
-const claude$2 = {
-    model: "claude",
-    options: {
-        reference: true,
-        separate: null
-    },
-    functions: [ {
-        name: "write",
-        parameters: {
-            description: " Chain of Thinking properties for implementation\n\n------------------------------\n\nCurrent Type: {@link IAutoBeRealizeWriteApplication.IProps}",
-            type: "object",
-            properties: {
-                plan: {
-                    description: "Implementation plan and strategy.\n\nAnalyzes the provider function requirements, identifies related Prisma\nschemas, and outlines the implementation approach. Includes schema\nvalidation and API contract verification.",
-                    type: "string"
-                },
-                draft: {
-                    description: "Initial implementation draft.\n\nThe first complete implementation attempt based on the plan. May contain\nareas that need refinement in the review phase.",
-                    type: "string"
-                },
-                revise: {
-                    description: "Revision and finalization phase.\n\nReviews the draft implementation and produces the final code with all\nimprovements and corrections applied.",
-                    $ref: "#/$defs/IAutoBeRealizeWriteApplication.IReviseProps"
-                }
-            },
-            required: [ "plan", "draft", "revise" ],
-            additionalProperties: false,
-            $defs: {
-                "IAutoBeRealizeWriteApplication.IReviseProps": {
-                    type: "object",
-                    properties: {
-                        review: {
-                            description: "Review and improvement suggestions.\n\nIdentifies areas for improvement in the draft code, including:\n\n- Type safety enhancements\n- Prisma query optimizations\n- Null/undefined handling corrections\n- Authentication/authorization improvements\n- Error handling refinements",
-                            type: "string"
-                        },
-                        final: {
-                            description: "Final implementation code.\n\nThe complete, production-ready implementation with all review suggestions\napplied.\n\nReturns `null` if the draft is already perfect and needs no changes.",
-                            oneOf: [ {
-                                type: "null"
-                            }, {
-                                type: "string"
-                            } ]
-                        }
-                    },
-                    required: [ "review", "final" ]
-                }
-            }
-        },
-        description: "Generate complete provider function implementation using Chain of Thinking.\n\nFollows a 3-phase process: plan → draft → revise.\n\nEnsures type safety, proper Prisma usage, and API contract compliance.",
-        validate: (() => {
+    const validate = input => {
+        const result = (() => {
             const _io0 = input => "string" === typeof input.plan && "string" === typeof input.draft && ("object" === typeof input.revise && null !== input.revise && _io1(input.revise));
             const _io1 = input => "string" === typeof input.review && (null === input.final || "string" === typeof input.final);
             const _vo0 = (input, _path, _exceptionable = true) => [ "string" === typeof input.plan || _report(_exceptionable, {
@@ -28323,127 +28488,279 @@ const claude$2 = {
                     data: input
                 };
             };
-        })()
-    } ]
-};
+        })()(input);
+        if (result.success === false) return result;
+        const errors = validateEmptyCode({
+            functionName: props.functionName,
+            draft: result.data.draft,
+            revise: result.data.revise
+        });
+        return errors.length ? {
+            success: false,
+            errors,
+            data: result.data
+        } : result;
+    };
+    const application = collection$7[props.model === "chatgpt" ? "chatgpt" : "claude"](validate);
+    return {
+        protocol: "class",
+        name: "Write code",
+        application,
+        execute: {
+            write: next => {
+                props.build(next);
+            }
+        }
+    };
+}
 
 const collection$7 = {
-    chatgpt: {
-        model: "chatgpt",
-        options: {
-            reference: true,
-            strict: false,
-            separate: null
-        },
-        functions: [ {
-            name: "write",
-            parameters: {
-                description: " Chain of Thinking properties for implementation\n\n------------------------------\n\nCurrent Type: {@link IAutoBeRealizeWriteApplication.IProps}\n\n### Description of {@link revise} property:\n\n> Revision and finalization phase.\n> \n> Reviews the draft implementation and produces the final code with all\n> improvements and corrections applied.",
-                type: "object",
-                properties: {
-                    plan: {
-                        description: "Implementation plan and strategy.\n\nAnalyzes the provider function requirements, identifies related Prisma\nschemas, and outlines the implementation approach. Includes schema\nvalidation and API contract verification.",
-                        type: "string"
-                    },
-                    draft: {
-                        description: "Initial implementation draft.\n\nThe first complete implementation attempt based on the plan. May contain\nareas that need refinement in the review phase.",
-                        type: "string"
+    chatgpt: validate => (() => {
+        const application = {
+            model: "chatgpt",
+            options: {
+                reference: true,
+                strict: false,
+                separate: null
+            },
+            functions: [ {
+                name: "write",
+                parameters: {
+                    description: " Chain of Thinking properties for implementation\n\n------------------------------\n\nCurrent Type: {@link IAutoBeRealizeWriteApplication.IProps}\n\n### Description of {@link revise} property:\n\n> Revision and finalization phase.\n> \n> Reviews the draft implementation and produces the final code with all\n> improvements and corrections applied.",
+                    type: "object",
+                    properties: {
+                        plan: {
+                            description: "Implementation plan and strategy.\n\nAnalyzes the provider function requirements, identifies related Prisma\nschemas, and outlines the implementation approach. Includes schema\nvalidation and API contract verification.",
+                            type: "string"
+                        },
+                        draft: {
+                            description: "Initial implementation draft.\n\nThe first complete implementation attempt based on the plan. May contain\nareas that need refinement in the review phase.",
+                            type: "string"
+                        },
+                        revise: {
+                            $ref: "#/$defs/IAutoBeRealizeWriteApplication.IReviseProps"
+                        }
                     },
-                    revise: {
-                        $ref: "#/$defs/IAutoBeRealizeWriteApplication.IReviseProps"
-                    }
-                },
-                required: [ "plan", "draft", "revise" ],
-                additionalProperties: false,
-                $defs: {
-                    "IAutoBeRealizeWriteApplication.IReviseProps": {
-                        type: "object",
-                        properties: {
-                            review: {
-                                description: "Review and improvement suggestions.\n\nIdentifies areas for improvement in the draft code, including:\n\n- Type safety enhancements\n- Prisma query optimizations\n- Null/undefined handling corrections\n- Authentication/authorization improvements\n- Error handling refinements",
-                                type: "string"
-                            },
-                            final: {
-                                description: "Final implementation code.\n\nThe complete, production-ready implementation with all review suggestions\napplied.\n\nReturns `null` if the draft is already perfect and needs no changes.",
-                                anyOf: [ {
-                                    type: "null"
-                                }, {
+                    required: [ "plan", "draft", "revise" ],
+                    additionalProperties: false,
+                    $defs: {
+                        "IAutoBeRealizeWriteApplication.IReviseProps": {
+                            type: "object",
+                            properties: {
+                                review: {
+                                    description: "Review and improvement suggestions.\n\nIdentifies areas for improvement in the draft code, including:\n\n- Type safety enhancements\n- Prisma query optimizations\n- Null/undefined handling corrections\n- Authentication/authorization improvements\n- Error handling refinements",
                                     type: "string"
-                                } ]
-                            }
-                        },
-                        required: [ "review", "final" ]
+                                },
+                                final: {
+                                    description: "Final implementation code.\n\nThe complete, production-ready implementation with all review suggestions\napplied.\n\nReturns `null` if the draft is already perfect and needs no changes.",
+                                    anyOf: [ {
+                                        type: "null"
+                                    }, {
+                                        type: "string"
+                                    } ]
+                                }
+                            },
+                            required: [ "review", "final" ]
+                        }
                     }
+                },
+                description: "Generate complete provider function implementation using Chain of Thinking.\n\nFollows a 3-phase process: plan → draft → revise.\n\nEnsures type safety, proper Prisma usage, and API contract compliance.",
+                validate: (() => {
+                    const _io0 = input => "string" === typeof input.plan && "string" === typeof input.draft && ("object" === typeof input.revise && null !== input.revise && _io1(input.revise));
+                    const _io1 = input => "string" === typeof input.review && (null === input.final || "string" === typeof input.final);
+                    const _vo0 = (input, _path, _exceptionable = true) => [ "string" === typeof input.plan || _report(_exceptionable, {
+                        path: _path + ".plan",
+                        expected: "string",
+                        value: input.plan
+                    }), "string" === typeof input.draft || _report(_exceptionable, {
+                        path: _path + ".draft",
+                        expected: "string",
+                        value: input.draft
+                    }), ("object" === typeof input.revise && null !== input.revise || _report(_exceptionable, {
+                        path: _path + ".revise",
+                        expected: "IAutoBeRealizeWriteApplication.IReviseProps",
+                        value: input.revise
+                    })) && _vo1(input.revise, _path + ".revise", _exceptionable) || _report(_exceptionable, {
+                        path: _path + ".revise",
+                        expected: "IAutoBeRealizeWriteApplication.IReviseProps",
+                        value: input.revise
+                    }) ].every(flag => flag);
+                    const _vo1 = (input, _path, _exceptionable = true) => [ "string" === typeof input.review || _report(_exceptionable, {
+                        path: _path + ".review",
+                        expected: "string",
+                        value: input.review
+                    }), null === input.final || "string" === typeof input.final || _report(_exceptionable, {
+                        path: _path + ".final",
+                        expected: "(null | string)",
+                        value: input.final
+                    }) ].every(flag => flag);
+                    const __is = input => "object" === typeof input && null !== input && _io0(input);
+                    let errors;
+                    let _report;
+                    return input => {
+                        if (false === __is(input)) {
+                            errors = [];
+                            _report = __typia_transform__validateReport._validateReport(errors);
+                            ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
+                                path: _path + "",
+                                expected: "IAutoBeRealizeWriteApplication.IProps",
+                                value: input
+                            })) && _vo0(input, _path + "", true) || _report(true, {
+                                path: _path + "",
+                                expected: "IAutoBeRealizeWriteApplication.IProps",
+                                value: input
+                            }))(input, "$input", true);
+                            const success = 0 === errors.length;
+                            return success ? {
+                                success,
+                                data: input
+                            } : {
+                                success,
+                                errors,
+                                data: input
+                            };
+                        }
+                        return {
+                            success: true,
+                            data: input
+                        };
+                    };
+                })()
+            } ]
+        };
+        __typia_transform__llmApplicationFinalize._llmApplicationFinalize(application, {
+            ...{
+                validate: {
+                    write: validate
                 }
             },
-            description: "Generate complete provider function implementation using Chain of Thinking.\n\nFollows a 3-phase process: plan → draft → revise.\n\nEnsures type safety, proper Prisma usage, and API contract compliance.",
-            validate: (() => {
-                const _io0 = input => "string" === typeof input.plan && "string" === typeof input.draft && ("object" === typeof input.revise && null !== input.revise && _io1(input.revise));
-                const _io1 = input => "string" === typeof input.review && (null === input.final || "string" === typeof input.final);
-                const _vo0 = (input, _path, _exceptionable = true) => [ "string" === typeof input.plan || _report(_exceptionable, {
-                    path: _path + ".plan",
-                    expected: "string",
-                    value: input.plan
-                }), "string" === typeof input.draft || _report(_exceptionable, {
-                    path: _path + ".draft",
-                    expected: "string",
-                    value: input.draft
-                }), ("object" === typeof input.revise && null !== input.revise || _report(_exceptionable, {
-                    path: _path + ".revise",
-                    expected: "IAutoBeRealizeWriteApplication.IReviseProps",
-                    value: input.revise
-                })) && _vo1(input.revise, _path + ".revise", _exceptionable) || _report(_exceptionable, {
-                    path: _path + ".revise",
-                    expected: "IAutoBeRealizeWriteApplication.IReviseProps",
-                    value: input.revise
-                }) ].every(flag => flag);
-                const _vo1 = (input, _path, _exceptionable = true) => [ "string" === typeof input.review || _report(_exceptionable, {
-                    path: _path + ".review",
-                    expected: "string",
-                    value: input.review
-                }), null === input.final || "string" === typeof input.final || _report(_exceptionable, {
-                    path: _path + ".final",
-                    expected: "(null | string)",
-                    value: input.final
-                }) ].every(flag => flag);
-                const __is = input => "object" === typeof input && null !== input && _io0(input);
-                let errors;
-                let _report;
-                return input => {
-                    if (false === __is(input)) {
-                        errors = [];
-                        _report = __typia_transform__validateReport._validateReport(errors);
-                        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
-                            path: _path + "",
-                            expected: "IAutoBeRealizeWriteApplication.IProps",
-                            value: input
-                        })) && _vo0(input, _path + "", true) || _report(true, {
-                            path: _path + "",
-                            expected: "IAutoBeRealizeWriteApplication.IProps",
-                            value: input
-                        }))(input, "$input", true);
-                        const success = 0 === errors.length;
-                        return success ? {
-                            success,
-                            data: input
-                        } : {
-                            success,
-                            errors,
+            equals: false
+        });
+        return application;
+    })(),
+    claude: validate => (() => {
+        const application = {
+            model: "claude",
+            options: {
+                reference: true,
+                separate: null
+            },
+            functions: [ {
+                name: "write",
+                parameters: {
+                    description: " Chain of Thinking properties for implementation\n\n------------------------------\n\nCurrent Type: {@link IAutoBeRealizeWriteApplication.IProps}",
+                    type: "object",
+                    properties: {
+                        plan: {
+                            description: "Implementation plan and strategy.\n\nAnalyzes the provider function requirements, identifies related Prisma\nschemas, and outlines the implementation approach. Includes schema\nvalidation and API contract verification.",
+                            type: "string"
+                        },
+                        draft: {
+                            description: "Initial implementation draft.\n\nThe first complete implementation attempt based on the plan. May contain\nareas that need refinement in the review phase.",
+                            type: "string"
+                        },
+                        revise: {
+                            description: "Revision and finalization phase.\n\nReviews the draft implementation and produces the final code with all\nimprovements and corrections applied.",
+                            $ref: "#/$defs/IAutoBeRealizeWriteApplication.IReviseProps"
+                        }
+                    },
+                    required: [ "plan", "draft", "revise" ],
+                    additionalProperties: false,
+                    $defs: {
+                        "IAutoBeRealizeWriteApplication.IReviseProps": {
+                            type: "object",
+                            properties: {
+                                review: {
+                                    description: "Review and improvement suggestions.\n\nIdentifies areas for improvement in the draft code, including:\n\n- Type safety enhancements\n- Prisma query optimizations\n- Null/undefined handling corrections\n- Authentication/authorization improvements\n- Error handling refinements",
+                                    type: "string"
+                                },
+                                final: {
+                                    description: "Final implementation code.\n\nThe complete, production-ready implementation with all review suggestions\napplied.\n\nReturns `null` if the draft is already perfect and needs no changes.",
+                                    oneOf: [ {
+                                        type: "null"
+                                    }, {
+                                        type: "string"
+                                    } ]
+                                }
+                            },
+                            required: [ "review", "final" ]
+                        }
+                    }
+                },
+                description: "Generate complete provider function implementation using Chain of Thinking.\n\nFollows a 3-phase process: plan → draft → revise.\n\nEnsures type safety, proper Prisma usage, and API contract compliance.",
+                validate: (() => {
+                    const _io0 = input => "string" === typeof input.plan && "string" === typeof input.draft && ("object" === typeof input.revise && null !== input.revise && _io1(input.revise));
+                    const _io1 = input => "string" === typeof input.review && (null === input.final || "string" === typeof input.final);
+                    const _vo0 = (input, _path, _exceptionable = true) => [ "string" === typeof input.plan || _report(_exceptionable, {
+                        path: _path + ".plan",
+                        expected: "string",
+                        value: input.plan
+                    }), "string" === typeof input.draft || _report(_exceptionable, {
+                        path: _path + ".draft",
+                        expected: "string",
+                        value: input.draft
+                    }), ("object" === typeof input.revise && null !== input.revise || _report(_exceptionable, {
+                        path: _path + ".revise",
+                        expected: "IAutoBeRealizeWriteApplication.IReviseProps",
+                        value: input.revise
+                    })) && _vo1(input.revise, _path + ".revise", _exceptionable) || _report(_exceptionable, {
+                        path: _path + ".revise",
+                        expected: "IAutoBeRealizeWriteApplication.IReviseProps",
+                        value: input.revise
+                    }) ].every(flag => flag);
+                    const _vo1 = (input, _path, _exceptionable = true) => [ "string" === typeof input.review || _report(_exceptionable, {
+                        path: _path + ".review",
+                        expected: "string",
+                        value: input.review
+                    }), null === input.final || "string" === typeof input.final || _report(_exceptionable, {
+                        path: _path + ".final",
+                        expected: "(null | string)",
+                        value: input.final
+                    }) ].every(flag => flag);
+                    const __is = input => "object" === typeof input && null !== input && _io0(input);
+                    let errors;
+                    let _report;
+                    return input => {
+                        if (false === __is(input)) {
+                            errors = [];
+                            _report = __typia_transform__validateReport._validateReport(errors);
+                            ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
+                                path: _path + "",
+                                expected: "IAutoBeRealizeWriteApplication.IProps",
+                                value: input
+                            })) && _vo0(input, _path + "", true) || _report(true, {
+                                path: _path + "",
+                                expected: "IAutoBeRealizeWriteApplication.IProps",
+                                value: input
+                            }))(input, "$input", true);
+                            const success = 0 === errors.length;
+                            return success ? {
+                                success,
+                                data: input
+                            } : {
+                                success,
+                                errors,
+                                data: input
+                            };
+                        }
+                        return {
+                            success: true,
                             data: input
                         };
-                    }
-                    return {
-                        success: true,
-                        data: input
                     };
-                };
-            })()
-        } ]
-    },
-    claude: claude$2,
-    llama: claude$2,
-    deepseek: claude$2,
-    3.1: claude$2
+                })()
+            } ]
+        };
+        __typia_transform__llmApplicationFinalize._llmApplicationFinalize(application, {
+            ...{
+                validate: {
+                    write: validate
+                }
+            },
+            equals: false
+        });
+        return application;
+    })()
 };
 
 function generateRealizeScenario(ctx, operation, authorizations) {
@@ -28621,6 +28938,7 @@ const correct$2 = async (ctx, factory, failures, script, event, life) => {
         }))),
         controller: createController$5({
             model: ctx.model,
+            functionName: factory.functionName,
             then: next => {
                 pointer.value = next;
             },
@@ -28650,7 +28968,81 @@ const correct$2 = async (ctx, factory, failures, script, event, life) => {
 
 const createController$5 = props => {
     assertSchemaModel(props.model);
-    const application = collection$6[props.model === "chatgpt" ? "chatgpt" : "claude"];
+    const validate = input => {
+        const result = (() => {
+            const _io0 = input => "string" === typeof input.think && "string" === typeof input.draft && ("object" === typeof input.revise && null !== input.revise && _io1(input.revise));
+            const _io1 = input => "string" === typeof input.review && (null === input.final || "string" === typeof input.final);
+            const _vo0 = (input, _path, _exceptionable = true) => [ "string" === typeof input.think || _report(_exceptionable, {
+                path: _path + ".think",
+                expected: "string",
+                value: input.think
+            }), "string" === typeof input.draft || _report(_exceptionable, {
+                path: _path + ".draft",
+                expected: "string",
+                value: input.draft
+            }), ("object" === typeof input.revise && null !== input.revise || _report(_exceptionable, {
+                path: _path + ".revise",
+                expected: "IAutoBeCommonCorrectCastingApplication.IReviseProps",
+                value: input.revise
+            })) && _vo1(input.revise, _path + ".revise", _exceptionable) || _report(_exceptionable, {
+                path: _path + ".revise",
+                expected: "IAutoBeCommonCorrectCastingApplication.IReviseProps",
+                value: input.revise
+            }) ].every(flag => flag);
+            const _vo1 = (input, _path, _exceptionable = true) => [ "string" === typeof input.review || _report(_exceptionable, {
+                path: _path + ".review",
+                expected: "string",
+                value: input.review
+            }), null === input.final || "string" === typeof input.final || _report(_exceptionable, {
+                path: _path + ".final",
+                expected: "(null | string)",
+                value: input.final
+            }) ].every(flag => flag);
+            const __is = input => "object" === typeof input && null !== input && _io0(input);
+            let errors;
+            let _report;
+            return input => {
+                if (false === __is(input)) {
+                    errors = [];
+                    _report = __typia_transform__validateReport._validateReport(errors);
+                    ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
+                        path: _path + "",
+                        expected: "IAutoBeCommonCorrectCastingApplication.IProps",
+                        value: input
+                    })) && _vo0(input, _path + "", true) || _report(true, {
+                        path: _path + "",
+                        expected: "IAutoBeCommonCorrectCastingApplication.IProps",
+                        value: input
+                    }))(input, "$input", true);
+                    const success = 0 === errors.length;
+                    return success ? {
+                        success,
+                        data: input
+                    } : {
+                        success,
+                        errors,
+                        data: input
+                    };
+                }
+                return {
+                    success: true,
+                    data: input
+                };
+            };
+        })()(input);
+        if (result.success === false) return result;
+        const errors = validateEmptyCode({
+            functionName: props.functionName,
+            draft: result.data.draft,
+            revise: result.data.revise
+        });
+        return errors.length ? {
+            success: false,
+            errors,
+            data: result.data
+        } : result;
+    };
+    const application = collection$6[props.model === "chatgpt" ? "chatgpt" : "claude"](validate);
     return {
         protocol: "class",
         name: "correctInvalidRequest",
@@ -28667,258 +29059,288 @@ const createController$5 = props => {
 };
 
 const collection$6 = {
-    chatgpt: {
-        model: "chatgpt",
-        options: {
-            reference: true,
-            strict: false,
-            separate: null
-        },
-        functions: [ {
-            name: "rewrite",
-            parameters: {
-                description: " - The analysis and correction properties\n\n------------------------------\n\nCurrent Type: {@link IAutoBeCommonCorrectCastingApplication.IProps}\n\n### Description of {@link revise} property:\n\n> Review and finalization of type casting corrections.\n> \n> Contains the review of applied corrections and the final code with all\n> type casting issues resolved while preserving type safety and validation\n> intent.",
-                type: "object",
-                properties: {
-                    think: {
-                        description: "Initial analysis of the type casting or assignment error.\n\nContains the agent's analysis of the specific type mismatch pattern:\n\n- Type of casting error (tag incompatibility, nullable assignment, literal\n  type conversion, etc.)\n- Whether nullable or undefined types are involved\n- If Date to string conversions are needed\n- The chosen fix strategy for the specific error type",
-                        type: "string"
-                    },
-                    draft: {
-                        description: "Draft correction with initial type casting fixes.\n\nThe code after applying the first round of fixes:\n\n- Satisfies patterns for tag stripping\n- Date.toISOString() conversions where needed\n- Nullable type narrowing checks\n- Literal type assertions\n- Optional chaining result handling",
-                        type: "string"
+    chatgpt: validate => (() => {
+        const application = {
+            model: "chatgpt",
+            options: {
+                reference: true,
+                strict: false,
+                separate: null
+            },
+            functions: [ {
+                name: "rewrite",
+                parameters: {
+                    description: " - The analysis and correction properties\n\n------------------------------\n\nCurrent Type: {@link IAutoBeCommonCorrectCastingApplication.IProps}\n\n### Description of {@link revise} property:\n\n> Review and finalization of type casting corrections.\n> \n> Contains the review of applied corrections and the final code with all\n> type casting issues resolved while preserving type safety and validation\n> intent.",
+                    type: "object",
+                    properties: {
+                        think: {
+                            description: "Initial analysis of the type casting or assignment error.\n\nContains the agent's analysis of the specific type mismatch pattern:\n\n- Type of casting error (tag incompatibility, nullable assignment, literal\n  type conversion, etc.)\n- Whether nullable or undefined types are involved\n- If Date to string conversions are needed\n- The chosen fix strategy for the specific error type",
+                            type: "string"
+                        },
+                        draft: {
+                            description: "Draft correction with initial type casting fixes.\n\nThe code after applying the first round of fixes:\n\n- Satisfies patterns for tag stripping\n- Date.toISOString() conversions where needed\n- Nullable type narrowing checks\n- Literal type assertions\n- Optional chaining result handling",
+                            type: "string"
+                        },
+                        revise: {
+                            $ref: "#/$defs/IAutoBeCommonCorrectCastingApplication.IReviseProps"
+                        }
                     },
-                    revise: {
-                        $ref: "#/$defs/IAutoBeCommonCorrectCastingApplication.IReviseProps"
-                    }
-                },
-                required: [ "think", "draft", "revise" ],
-                additionalProperties: false,
-                $defs: {
-                    "IAutoBeCommonCorrectCastingApplication.IReviseProps": {
-                        type: "object",
-                        properties: {
-                            review: {
-                                description: "Review of the type casting correction patterns applied.\n\nExplains which correction strategies were used:\n\n- Which satisfies patterns were applied for tag issues\n- Where typia.assert or assertGuard was used\n- How Date conversions were handled\n- What nullable type narrowing was applied\n- How literal type conversions were resolved\n- Confirmation that all type casting issues are resolved",
-                                type: "string"
-                            },
-                            final: {
-                                description: "Final corrected code with all type casting issues resolved.\n\nThe complete code ready for TypeScript compilation, with all type casting\nand assignment errors properly fixed using appropriate patterns while\nmaintaining type safety and the original validation logic. When the draft\nalready successfully resolves all type casting issues with no problems\nfound during review, this value can be null, indicating no further\nrefinements are necessary.\n\nA `null` value signifies the draft corrections were already optimal and\nrequire no additional modifications.",
-                                anyOf: [ {
-                                    type: "null"
-                                }, {
+                    required: [ "think", "draft", "revise" ],
+                    additionalProperties: false,
+                    $defs: {
+                        "IAutoBeCommonCorrectCastingApplication.IReviseProps": {
+                            type: "object",
+                            properties: {
+                                review: {
+                                    description: "Review of the type casting correction patterns applied.\n\nExplains which correction strategies were used:\n\n- Which satisfies patterns were applied for tag issues\n- Where typia.assert or assertGuard was used\n- How Date conversions were handled\n- What nullable type narrowing was applied\n- How literal type conversions were resolved\n- Confirmation that all type casting issues are resolved",
                                     type: "string"
-                                } ]
-                            }
-                        },
-                        required: [ "review", "final" ]
+                                },
+                                final: {
+                                    description: "Final corrected code with all type casting issues resolved.\n\nThe complete code ready for TypeScript compilation, with all type casting\nand assignment errors properly fixed using appropriate patterns while\nmaintaining type safety and the original validation logic. When the draft\nalready successfully resolves all type casting issues with no problems\nfound during review, this value can be null, indicating no further\nrefinements are necessary.\n\nA `null` value signifies the draft corrections were already optimal and\nrequire no additional modifications.",
+                                    anyOf: [ {
+                                        type: "null"
+                                    }, {
+                                        type: "string"
+                                    } ]
+                                }
+                            },
+                            required: [ "review", "final" ]
+                        }
                     }
-                }
-            },
-            description: 'Rewrite function to fix type casting and assignment errors.\n\nThis function is called when the agent detects any type casting or\nassignment related compilation error patterns.\n\nThe agent applies various fix strategies based on the error type:\n\n- **Typia tag incompatibilities**: Uses `satisfies ... as ...` pattern to\n  strip incompatible tags, or `typia.assert<T>()` as a last resort\n- **Date conversions**: Uses `.toISOString()` method for Date to string\n  conversions\n- **Nullable type narrowing**: Applies exhaustive checks (e.g., !== null &&\n  !== undefined)\n- **typia.assert vs assertGuard**: Uses assert for value assignment,\n  assertGuard for type narrowing\n- **Literal type conversions**: Uses `typia.assert<T>()` for runtime\n  validation\n- **Optional chaining results**: Uses `=== true` or `??` operators\n- **"No overlap" errors**: Removes redundant comparisons',
-            validate: (() => {
-                const _io0 = input => "string" === typeof input.think && "string" === typeof input.draft && ("object" === typeof input.revise && null !== input.revise && _io1(input.revise));
-                const _io1 = input => "string" === typeof input.review && (null === input.final || "string" === typeof input.final);
-                const _vo0 = (input, _path, _exceptionable = true) => [ "string" === typeof input.think || _report(_exceptionable, {
-                    path: _path + ".think",
-                    expected: "string",
-                    value: input.think
-                }), "string" === typeof input.draft || _report(_exceptionable, {
-                    path: _path + ".draft",
-                    expected: "string",
-                    value: input.draft
-                }), ("object" === typeof input.revise && null !== input.revise || _report(_exceptionable, {
-                    path: _path + ".revise",
-                    expected: "IAutoBeCommonCorrectCastingApplication.IReviseProps",
-                    value: input.revise
-                })) && _vo1(input.revise, _path + ".revise", _exceptionable) || _report(_exceptionable, {
-                    path: _path + ".revise",
-                    expected: "IAutoBeCommonCorrectCastingApplication.IReviseProps",
-                    value: input.revise
-                }) ].every(flag => flag);
-                const _vo1 = (input, _path, _exceptionable = true) => [ "string" === typeof input.review || _report(_exceptionable, {
-                    path: _path + ".review",
-                    expected: "string",
-                    value: input.review
-                }), null === input.final || "string" === typeof input.final || _report(_exceptionable, {
-                    path: _path + ".final",
-                    expected: "(null | string)",
-                    value: input.final
-                }) ].every(flag => flag);
-                const __is = input => "object" === typeof input && null !== input && _io0(input);
-                let errors;
-                let _report;
-                return input => {
-                    if (false === __is(input)) {
-                        errors = [];
-                        _report = __typia_transform__validateReport._validateReport(errors);
-                        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
-                            path: _path + "",
-                            expected: "IAutoBeCommonCorrectCastingApplication.IProps",
-                            value: input
-                        })) && _vo0(input, _path + "", true) || _report(true, {
-                            path: _path + "",
-                            expected: "IAutoBeCommonCorrectCastingApplication.IProps",
-                            value: input
-                        }))(input, "$input", true);
-                        const success = 0 === errors.length;
-                        return success ? {
-                            success,
-                            data: input
-                        } : {
-                            success,
-                            errors,
+                },
+                description: 'Rewrite function to fix type casting and assignment errors.\n\nThis function is called when the agent detects any type casting or\nassignment related compilation error patterns.\n\nThe agent applies various fix strategies based on the error type:\n\n- **Typia tag incompatibilities**: Uses `satisfies ... as ...` pattern to\n  strip incompatible tags, or `typia.assert<T>()` as a last resort\n- **Date conversions**: Uses `.toISOString()` method for Date to string\n  conversions\n- **Nullable type narrowing**: Applies exhaustive checks (e.g., !== null &&\n  !== undefined)\n- **typia.assert vs assertGuard**: Uses assert for value assignment,\n  assertGuard for type narrowing\n- **Literal type conversions**: Uses `typia.assert<T>()` for runtime\n  validation\n- **Optional chaining results**: Uses `=== true` or `??` operators\n- **"No overlap" errors**: Removes redundant comparisons',
+                validate: (() => {
+                    const _io0 = input => "string" === typeof input.think && "string" === typeof input.draft && ("object" === typeof input.revise && null !== input.revise && _io1(input.revise));
+                    const _io1 = input => "string" === typeof input.review && (null === input.final || "string" === typeof input.final);
+                    const _vo0 = (input, _path, _exceptionable = true) => [ "string" === typeof input.think || _report(_exceptionable, {
+                        path: _path + ".think",
+                        expected: "string",
+                        value: input.think
+                    }), "string" === typeof input.draft || _report(_exceptionable, {
+                        path: _path + ".draft",
+                        expected: "string",
+                        value: input.draft
+                    }), ("object" === typeof input.revise && null !== input.revise || _report(_exceptionable, {
+                        path: _path + ".revise",
+                        expected: "IAutoBeCommonCorrectCastingApplication.IReviseProps",
+                        value: input.revise
+                    })) && _vo1(input.revise, _path + ".revise", _exceptionable) || _report(_exceptionable, {
+                        path: _path + ".revise",
+                        expected: "IAutoBeCommonCorrectCastingApplication.IReviseProps",
+                        value: input.revise
+                    }) ].every(flag => flag);
+                    const _vo1 = (input, _path, _exceptionable = true) => [ "string" === typeof input.review || _report(_exceptionable, {
+                        path: _path + ".review",
+                        expected: "string",
+                        value: input.review
+                    }), null === input.final || "string" === typeof input.final || _report(_exceptionable, {
+                        path: _path + ".final",
+                        expected: "(null | string)",
+                        value: input.final
+                    }) ].every(flag => flag);
+                    const __is = input => "object" === typeof input && null !== input && _io0(input);
+                    let errors;
+                    let _report;
+                    return input => {
+                        if (false === __is(input)) {
+                            errors = [];
+                            _report = __typia_transform__validateReport._validateReport(errors);
+                            ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
+                                path: _path + "",
+                                expected: "IAutoBeCommonCorrectCastingApplication.IProps",
+                                value: input
+                            })) && _vo0(input, _path + "", true) || _report(true, {
+                                path: _path + "",
+                                expected: "IAutoBeCommonCorrectCastingApplication.IProps",
+                                value: input
+                            }))(input, "$input", true);
+                            const success = 0 === errors.length;
+                            return success ? {
+                                success,
+                                data: input
+                            } : {
+                                success,
+                                errors,
+                                data: input
+                            };
+                        }
+                        return {
+                            success: true,
                             data: input
                         };
-                    }
-                    return {
-                        success: true,
-                        data: input
                     };
-                };
-            })()
-        }, {
-            name: "reject",
-            parameters: {
-                type: "object",
-                properties: {},
-                additionalProperties: false,
-                required: [],
-                $defs: {}
+                })()
+            }, {
+                name: "reject",
+                parameters: {
+                    type: "object",
+                    properties: {},
+                    additionalProperties: false,
+                    required: [],
+                    $defs: {}
+                },
+                description: "Reject function when error is not related to type casting or assignment.\n\nThis function is called when the compilation error is unrelated to type\ncasting issues (e.g., missing imports, syntax errors, undefined variables),\nindicating the error should be handled by a different agent.",
+                validate: (() => input => ({
+                    success: true,
+                    data: input
+                }))()
+            } ]
+        };
+        __typia_transform__llmApplicationFinalize._llmApplicationFinalize(application, {
+            ...{
+                validate: {
+                    rewrite: validate,
+                    reject: () => ({
+                        success: true,
+                        data: undefined
+                    })
+                }
             },
-            description: "Reject function when error is not related to type casting or assignment.\n\nThis function is called when the compilation error is unrelated to type\ncasting issues (e.g., missing imports, syntax errors, undefined variables),\nindicating the error should be handled by a different agent.",
-            validate: (() => input => ({
-                success: true,
-                data: input
-            }))()
-        } ]
-    },
-    claude: {
-        model: "claude",
-        options: {
-            reference: true,
-            separate: null
-        },
-        functions: [ {
-            name: "rewrite",
-            parameters: {
-                description: " - The analysis and correction properties\n\n------------------------------\n\nCurrent Type: {@link IAutoBeCommonCorrectCastingApplication.IProps}",
-                type: "object",
-                properties: {
-                    think: {
-                        description: "Initial analysis of the type casting or assignment error.\n\nContains the agent's analysis of the specific type mismatch pattern:\n\n- Type of casting error (tag incompatibility, nullable assignment, literal\n  type conversion, etc.)\n- Whether nullable or undefined types are involved\n- If Date to string conversions are needed\n- The chosen fix strategy for the specific error type",
-                        type: "string"
-                    },
-                    draft: {
-                        description: "Draft correction with initial type casting fixes.\n\nThe code after applying the first round of fixes:\n\n- Satisfies patterns for tag stripping\n- Date.toISOString() conversions where needed\n- Nullable type narrowing checks\n- Literal type assertions\n- Optional chaining result handling",
-                        type: "string"
+            equals: false
+        });
+        return application;
+    })(),
+    claude: validate => (() => {
+        const application = {
+            model: "claude",
+            options: {
+                reference: true,
+                separate: null
+            },
+            functions: [ {
+                name: "rewrite",
+                parameters: {
+                    description: " - The analysis and correction properties\n\n------------------------------\n\nCurrent Type: {@link IAutoBeCommonCorrectCastingApplication.IProps}",
+                    type: "object",
+                    properties: {
+                        think: {
+                            description: "Initial analysis of the type casting or assignment error.\n\nContains the agent's analysis of the specific type mismatch pattern:\n\n- Type of casting error (tag incompatibility, nullable assignment, literal\n  type conversion, etc.)\n- Whether nullable or undefined types are involved\n- If Date to string conversions are needed\n- The chosen fix strategy for the specific error type",
+                            type: "string"
+                        },
+                        draft: {
+                            description: "Draft correction with initial type casting fixes.\n\nThe code after applying the first round of fixes:\n\n- Satisfies patterns for tag stripping\n- Date.toISOString() conversions where needed\n- Nullable type narrowing checks\n- Literal type assertions\n- Optional chaining result handling",
+                            type: "string"
+                        },
+                        revise: {
+                            description: "Review and finalization of type casting corrections.\n\nContains the review of applied corrections and the final code with all\ntype casting issues resolved while preserving type safety and validation\nintent.",
+                            $ref: "#/$defs/IAutoBeCommonCorrectCastingApplication.IReviseProps"
+                        }
                     },
-                    revise: {
-                        description: "Review and finalization of type casting corrections.\n\nContains the review of applied corrections and the final code with all\ntype casting issues resolved while preserving type safety and validation\nintent.",
-                        $ref: "#/$defs/IAutoBeCommonCorrectCastingApplication.IReviseProps"
-                    }
-                },
-                required: [ "think", "draft", "revise" ],
-                additionalProperties: false,
-                $defs: {
-                    "IAutoBeCommonCorrectCastingApplication.IReviseProps": {
-                        type: "object",
-                        properties: {
-                            review: {
-                                description: "Review of the type casting correction patterns applied.\n\nExplains which correction strategies were used:\n\n- Which satisfies patterns were applied for tag issues\n- Where typia.assert or assertGuard was used\n- How Date conversions were handled\n- What nullable type narrowing was applied\n- How literal type conversions were resolved\n- Confirmation that all type casting issues are resolved",
-                                type: "string"
-                            },
-                            final: {
-                                description: "Final corrected code with all type casting issues resolved.\n\nThe complete code ready for TypeScript compilation, with all type casting\nand assignment errors properly fixed using appropriate patterns while\nmaintaining type safety and the original validation logic. When the draft\nalready successfully resolves all type casting issues with no problems\nfound during review, this value can be null, indicating no further\nrefinements are necessary.\n\nA `null` value signifies the draft corrections were already optimal and\nrequire no additional modifications.",
-                                oneOf: [ {
-                                    type: "null"
-                                }, {
+                    required: [ "think", "draft", "revise" ],
+                    additionalProperties: false,
+                    $defs: {
+                        "IAutoBeCommonCorrectCastingApplication.IReviseProps": {
+                            type: "object",
+                            properties: {
+                                review: {
+                                    description: "Review of the type casting correction patterns applied.\n\nExplains which correction strategies were used:\n\n- Which satisfies patterns were applied for tag issues\n- Where typia.assert or assertGuard was used\n- How Date conversions were handled\n- What nullable type narrowing was applied\n- How literal type conversions were resolved\n- Confirmation that all type casting issues are resolved",
                                     type: "string"
-                                } ]
-                            }
-                        },
-                        required: [ "review", "final" ]
+                                },
+                                final: {
+                                    description: "Final corrected code with all type casting issues resolved.\n\nThe complete code ready for TypeScript compilation, with all type casting\nand assignment errors properly fixed using appropriate patterns while\nmaintaining type safety and the original validation logic. When the draft\nalready successfully resolves all type casting issues with no problems\nfound during review, this value can be null, indicating no further\nrefinements are necessary.\n\nA `null` value signifies the draft corrections were already optimal and\nrequire no additional modifications.",
+                                    oneOf: [ {
+                                        type: "null"
+                                    }, {
+                                        type: "string"
+                                    } ]
+                                }
+                            },
+                            required: [ "review", "final" ]
+                        }
                     }
-                }
-            },
-            description: 'Rewrite function to fix type casting and assignment errors.\n\nThis function is called when the agent detects any type casting or\nassignment related compilation error patterns.\n\nThe agent applies various fix strategies based on the error type:\n\n- **Typia tag incompatibilities**: Uses `satisfies ... as ...` pattern to\n  strip incompatible tags, or `typia.assert<T>()` as a last resort\n- **Date conversions**: Uses `.toISOString()` method for Date to string\n  conversions\n- **Nullable type narrowing**: Applies exhaustive checks (e.g., !== null &&\n  !== undefined)\n- **typia.assert vs assertGuard**: Uses assert for value assignment,\n  assertGuard for type narrowing\n- **Literal type conversions**: Uses `typia.assert<T>()` for runtime\n  validation\n- **Optional chaining results**: Uses `=== true` or `??` operators\n- **"No overlap" errors**: Removes redundant comparisons',
-            validate: (() => {
-                const _io0 = input => "string" === typeof input.think && "string" === typeof input.draft && ("object" === typeof input.revise && null !== input.revise && _io1(input.revise));
-                const _io1 = input => "string" === typeof input.review && (null === input.final || "string" === typeof input.final);
-                const _vo0 = (input, _path, _exceptionable = true) => [ "string" === typeof input.think || _report(_exceptionable, {
-                    path: _path + ".think",
-                    expected: "string",
-                    value: input.think
-                }), "string" === typeof input.draft || _report(_exceptionable, {
-                    path: _path + ".draft",
-                    expected: "string",
-                    value: input.draft
-                }), ("object" === typeof input.revise && null !== input.revise || _report(_exceptionable, {
-                    path: _path + ".revise",
-                    expected: "IAutoBeCommonCorrectCastingApplication.IReviseProps",
-                    value: input.revise
-                })) && _vo1(input.revise, _path + ".revise", _exceptionable) || _report(_exceptionable, {
-                    path: _path + ".revise",
-                    expected: "IAutoBeCommonCorrectCastingApplication.IReviseProps",
-                    value: input.revise
-                }) ].every(flag => flag);
-                const _vo1 = (input, _path, _exceptionable = true) => [ "string" === typeof input.review || _report(_exceptionable, {
-                    path: _path + ".review",
-                    expected: "string",
-                    value: input.review
-                }), null === input.final || "string" === typeof input.final || _report(_exceptionable, {
-                    path: _path + ".final",
-                    expected: "(null | string)",
-                    value: input.final
-                }) ].every(flag => flag);
-                const __is = input => "object" === typeof input && null !== input && _io0(input);
-                let errors;
-                let _report;
-                return input => {
-                    if (false === __is(input)) {
-                        errors = [];
-                        _report = __typia_transform__validateReport._validateReport(errors);
-                        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
-                            path: _path + "",
-                            expected: "IAutoBeCommonCorrectCastingApplication.IProps",
-                            value: input
-                        })) && _vo0(input, _path + "", true) || _report(true, {
-                            path: _path + "",
-                            expected: "IAutoBeCommonCorrectCastingApplication.IProps",
-                            value: input
-                        }))(input, "$input", true);
-                        const success = 0 === errors.length;
-                        return success ? {
-                            success,
-                            data: input
-                        } : {
-                            success,
-                            errors,
+                },
+                description: 'Rewrite function to fix type casting and assignment errors.\n\nThis function is called when the agent detects any type casting or\nassignment related compilation error patterns.\n\nThe agent applies various fix strategies based on the error type:\n\n- **Typia tag incompatibilities**: Uses `satisfies ... as ...` pattern to\n  strip incompatible tags, or `typia.assert<T>()` as a last resort\n- **Date conversions**: Uses `.toISOString()` method for Date to string\n  conversions\n- **Nullable type narrowing**: Applies exhaustive checks (e.g., !== null &&\n  !== undefined)\n- **typia.assert vs assertGuard**: Uses assert for value assignment,\n  assertGuard for type narrowing\n- **Literal type conversions**: Uses `typia.assert<T>()` for runtime\n  validation\n- **Optional chaining results**: Uses `=== true` or `??` operators\n- **"No overlap" errors**: Removes redundant comparisons',
+                validate: (() => {
+                    const _io0 = input => "string" === typeof input.think && "string" === typeof input.draft && ("object" === typeof input.revise && null !== input.revise && _io1(input.revise));
+                    const _io1 = input => "string" === typeof input.review && (null === input.final || "string" === typeof input.final);
+                    const _vo0 = (input, _path, _exceptionable = true) => [ "string" === typeof input.think || _report(_exceptionable, {
+                        path: _path + ".think",
+                        expected: "string",
+                        value: input.think
+                    }), "string" === typeof input.draft || _report(_exceptionable, {
+                        path: _path + ".draft",
+                        expected: "string",
+                        value: input.draft
+                    }), ("object" === typeof input.revise && null !== input.revise || _report(_exceptionable, {
+                        path: _path + ".revise",
+                        expected: "IAutoBeCommonCorrectCastingApplication.IReviseProps",
+                        value: input.revise
+                    })) && _vo1(input.revise, _path + ".revise", _exceptionable) || _report(_exceptionable, {
+                        path: _path + ".revise",
+                        expected: "IAutoBeCommonCorrectCastingApplication.IReviseProps",
+                        value: input.revise
+                    }) ].every(flag => flag);
+                    const _vo1 = (input, _path, _exceptionable = true) => [ "string" === typeof input.review || _report(_exceptionable, {
+                        path: _path + ".review",
+                        expected: "string",
+                        value: input.review
+                    }), null === input.final || "string" === typeof input.final || _report(_exceptionable, {
+                        path: _path + ".final",
+                        expected: "(null | string)",
+                        value: input.final
+                    }) ].every(flag => flag);
+                    const __is = input => "object" === typeof input && null !== input && _io0(input);
+                    let errors;
+                    let _report;
+                    return input => {
+                        if (false === __is(input)) {
+                            errors = [];
+                            _report = __typia_transform__validateReport._validateReport(errors);
+                            ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
+                                path: _path + "",
+                                expected: "IAutoBeCommonCorrectCastingApplication.IProps",
+                                value: input
+                            })) && _vo0(input, _path + "", true) || _report(true, {
+                                path: _path + "",
+                                expected: "IAutoBeCommonCorrectCastingApplication.IProps",
+                                value: input
+                            }))(input, "$input", true);
+                            const success = 0 === errors.length;
+                            return success ? {
+                                success,
+                                data: input
+                            } : {
+                                success,
+                                errors,
+                                data: input
+                            };
+                        }
+                        return {
+                            success: true,
                             data: input
                         };
-                    }
-                    return {
-                        success: true,
-                        data: input
                     };
-                };
-            })()
-        }, {
-            name: "reject",
-            parameters: {
-                type: "object",
-                properties: {},
-                additionalProperties: false,
-                required: [],
-                $defs: {}
+                })()
+            }, {
+                name: "reject",
+                parameters: {
+                    type: "object",
+                    properties: {},
+                    additionalProperties: false,
+                    required: [],
+                    $defs: {}
+                },
+                description: "Reject function when error is not related to type casting or assignment.\n\nThis function is called when the compilation error is unrelated to type\ncasting issues (e.g., missing imports, syntax errors, undefined variables),\nindicating the error should be handled by a different agent.",
+                validate: (() => input => ({
+                    success: true,
+                    data: input
+                }))()
+            } ]
+        };
+        __typia_transform__llmApplicationFinalize._llmApplicationFinalize(application, {
+            ...{
+                validate: {
+                    rewrite: validate,
+                    reject: () => ({
+                        success: true,
+                        data: undefined
+                    })
+                }
             },
-            description: "Reject function when error is not related to type casting or assignment.\n\nThis function is called when the compilation error is unrelated to type\ncasting issues (e.g., missing imports, syntax errors, undefined variables),\nindicating the error should be handled by a different agent.",
-            validate: (() => input => ({
-                success: true,
-                data: input
-            }))()
-        } ]
-    }
+            equals: false
+        });
+        return application;
+    })()
 };
 
 const getTestImportStatements = document => {
@@ -29253,6 +29675,7 @@ const correct$1 = async (ctx, compile, write, event, life) => {
         histories: await transformTestCorrectInvalidRequestHistories(null, event.result.diagnostics),
         controller: createController$4({
             model: ctx.model,
+            functionName: write.scenario.functionName,
             then: next => {
                 pointer.value = next;
             },
@@ -29300,7 +29723,81 @@ const correct$1 = async (ctx, compile, write, event, life) => {
 
 const createController$4 = props => {
     assertSchemaModel(props.model);
-    const application = collection$5[props.model === "chatgpt" ? "chatgpt" : "claude"];
+    const validate = input => {
+        const result = (() => {
+            const _io0 = input => "string" === typeof input.think && "string" === typeof input.draft && ("object" === typeof input.revise && null !== input.revise && _io1(input.revise));
+            const _io1 = input => "string" === typeof input.review && (null === input.final || "string" === typeof input.final);
+            const _vo0 = (input, _path, _exceptionable = true) => [ "string" === typeof input.think || _report(_exceptionable, {
+                path: _path + ".think",
+                expected: "string",
+                value: input.think
+            }), "string" === typeof input.draft || _report(_exceptionable, {
+                path: _path + ".draft",
+                expected: "string",
+                value: input.draft
+            }), ("object" === typeof input.revise && null !== input.revise || _report(_exceptionable, {
+                path: _path + ".revise",
+                expected: "IAutoBeTestCorrectInvalidRequestApplication.IReviseProps",
+                value: input.revise
+            })) && _vo1(input.revise, _path + ".revise", _exceptionable) || _report(_exceptionable, {
+                path: _path + ".revise",
+                expected: "IAutoBeTestCorrectInvalidRequestApplication.IReviseProps",
+                value: input.revise
+            }) ].every(flag => flag);
+            const _vo1 = (input, _path, _exceptionable = true) => [ "string" === typeof input.review || _report(_exceptionable, {
+                path: _path + ".review",
+                expected: "string",
+                value: input.review
+            }), null === input.final || "string" === typeof input.final || _report(_exceptionable, {
+                path: _path + ".final",
+                expected: "(null | string)",
+                value: input.final
+            }) ].every(flag => flag);
+            const __is = input => "object" === typeof input && null !== input && _io0(input);
+            let errors;
+            let _report;
+            return input => {
+                if (false === __is(input)) {
+                    errors = [];
+                    _report = __typia_transform__validateReport._validateReport(errors);
+                    ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
+                        path: _path + "",
+                        expected: "IAutoBeTestCorrectInvalidRequestApplication.IProps",
+                        value: input
+                    })) && _vo0(input, _path + "", true) || _report(true, {
+                        path: _path + "",
+                        expected: "IAutoBeTestCorrectInvalidRequestApplication.IProps",
+                        value: input
+                    }))(input, "$input", true);
+                    const success = 0 === errors.length;
+                    return success ? {
+                        success,
+                        data: input
+                    } : {
+                        success,
+                        errors,
+                        data: input
+                    };
+                }
+                return {
+                    success: true,
+                    data: input
+                };
+            };
+        })()(input);
+        if (result.success === false) return result;
+        const errors = validateEmptyCode({
+            functionName: props.functionName,
+            draft: result.data.draft,
+            revise: result.data.revise
+        });
+        return errors.length ? {
+            success: false,
+            errors,
+            data: result.data
+        } : result;
+    };
+    const application = collection$5[props.model === "chatgpt" ? "chatgpt" : "claude"](validate);
     return {
         protocol: "class",
         name: "correctInvalidRequest",
@@ -29317,260 +29814,290 @@ const createController$4 = props => {
 };
 
 const collection$5 = {
-    chatgpt: {
-        model: "chatgpt",
-        options: {
-            reference: true,
-            strict: false,
-            separate: null
-        },
-        functions: [ {
-            name: "rewrite",
-            parameters: {
-                description: " - The analysis and correction properties\n\n------------------------------\n\nDescription of the current {@link IAutoBeTestCorrectInvalidRequestApplication.IProps} type:\n\n> Properties for the rewrite function containing the analysis and correction\n> workflow.\n> \n> This follows a three-phase approach: think → draft → revise, ensuring\n> systematic removal of invalid type testing code while maintaining the\n> integrity of valid E2E tests.\n\n### Description of {@link revise} property:\n\n> Review and finalization phase.\n> \n> Contains the review of changes made and the final cleaned code that\n> should compile without the invalid API request errors. This ensures the\n> correction is complete and accurate.",
-                type: "object",
-                properties: {
-                    think: {
-                        description: "Initial analysis phase.\n\nContains the agent's analysis of what specific invalid request pattern\nwas found in the code and how it's causing the compilation error. This\nshould identify:\n\n- The exact pattern (as any, satisfies, TestValidator.error, etc.)\n- Line numbers and locations of violations\n- The TypeScript error codes being triggered\n- Why this constitutes invalid type testing\n\nExample: \"Detected TestValidator.error() call at line 45 with 'as any'\ncasting on request body containing deliberately wrong types (number for\nemail field). This is causing TS2345 compilation error.\"",
-                        type: "string"
-                    },
-                    draft: {
-                        description: "Draft correction phase.\n\nThe initial corrected code with the problematic API request sections\ncompletely removed while preserving all valid test code.\n\nRules for drafting:\n\n- Remove entire test functions containing type violations\n- Do not comment out code - delete it completely\n- Preserve test suite structure and valid tests\n- Maintain proper indentation and formatting\n- Keep imports that are still needed by remaining code",
-                        type: "string"
+    chatgpt: validate => (() => {
+        const application = {
+            model: "chatgpt",
+            options: {
+                reference: true,
+                strict: false,
+                separate: null
+            },
+            functions: [ {
+                name: "rewrite",
+                parameters: {
+                    description: " - The analysis and correction properties\n\n------------------------------\n\nDescription of the current {@link IAutoBeTestCorrectInvalidRequestApplication.IProps} type:\n\n> Properties for the rewrite function containing the analysis and correction\n> workflow.\n> \n> This follows a three-phase approach: think → draft → revise, ensuring\n> systematic removal of invalid type testing code while maintaining the\n> integrity of valid E2E tests.\n\n### Description of {@link revise} property:\n\n> Review and finalization phase.\n> \n> Contains the review of changes made and the final cleaned code that\n> should compile without the invalid API request errors. This ensures the\n> correction is complete and accurate.",
+                    type: "object",
+                    properties: {
+                        think: {
+                            description: "Initial analysis phase.\n\nContains the agent's analysis of what specific invalid request pattern\nwas found in the code and how it's causing the compilation error. This\nshould identify:\n\n- The exact pattern (as any, satisfies, TestValidator.error, etc.)\n- Line numbers and locations of violations\n- The TypeScript error codes being triggered\n- Why this constitutes invalid type testing\n\nExample: \"Detected TestValidator.error() call at line 45 with 'as any'\ncasting on request body containing deliberately wrong types (number for\nemail field). This is causing TS2345 compilation error.\"",
+                            type: "string"
+                        },
+                        draft: {
+                            description: "Draft correction phase.\n\nThe initial corrected code with the problematic API request sections\ncompletely removed while preserving all valid test code.\n\nRules for drafting:\n\n- Remove entire test functions containing type violations\n- Do not comment out code - delete it completely\n- Preserve test suite structure and valid tests\n- Maintain proper indentation and formatting\n- Keep imports that are still needed by remaining code",
+                            type: "string"
+                        },
+                        revise: {
+                            $ref: "#/$defs/IAutoBeTestCorrectInvalidRequestApplication.IReviseProps"
+                        }
                     },
-                    revise: {
-                        $ref: "#/$defs/IAutoBeTestCorrectInvalidRequestApplication.IReviseProps"
-                    }
-                },
-                required: [ "think", "draft", "revise" ],
-                additionalProperties: false,
-                $defs: {
-                    "IAutoBeTestCorrectInvalidRequestApplication.IReviseProps": {
-                        description: "Properties for the revision phase of the correction process.\n\nThis phase ensures that the removal was complete and the remaining code is\nvalid and compilable.",
-                        type: "object",
-                        properties: {
-                            review: {
-                                description: 'Review of the changes made.\n\nBrief explanation of what invalid API request code was removed and\nverification that valid test code was preserved. Should confirm:\n\n- Which patterns were found and removed\n- Line ranges that were deleted\n- Verification that valid tests remain intact\n- Confirmation that no partial fixes were applied\n\nExample: "Removed lines 43-52 containing TestValidator.error with invalid\ntype casting. Verified remaining tests are valid and unaffected."',
-                                type: "string"
-                            },
-                            final: {
-                                description: "Final corrected code.\n\nThe complete, cleaned test code with all invalid API request sections\nremoved, ready for compilation. When the draft already successfully\nremoves all problematic code with no additional issues found during\nreview, this value can be null, indicating the draft deletion was\nsufficient and requires no further changes.\n\nThis code must:\n\n- Compile without TypeScript errors\n- Contain only valid business logic tests\n- Have no `as any` or similar type violations\n- Maintain the original file structure\n- Be production-ready E2E test code\n\nA null value indicates the draft successfully removed all invalid code\nand needs no additional modifications.",
-                                anyOf: [ {
-                                    type: "null"
-                                }, {
+                    required: [ "think", "draft", "revise" ],
+                    additionalProperties: false,
+                    $defs: {
+                        "IAutoBeTestCorrectInvalidRequestApplication.IReviseProps": {
+                            description: "Properties for the revision phase of the correction process.\n\nThis phase ensures that the removal was complete and the remaining code is\nvalid and compilable.",
+                            type: "object",
+                            properties: {
+                                review: {
+                                    description: 'Review of the changes made.\n\nBrief explanation of what invalid API request code was removed and\nverification that valid test code was preserved. Should confirm:\n\n- Which patterns were found and removed\n- Line ranges that were deleted\n- Verification that valid tests remain intact\n- Confirmation that no partial fixes were applied\n\nExample: "Removed lines 43-52 containing TestValidator.error with invalid\ntype casting. Verified remaining tests are valid and unaffected."',
                                     type: "string"
-                                } ]
-                            }
-                        },
-                        required: [ "review", "final" ]
+                                },
+                                final: {
+                                    description: "Final corrected code.\n\nThe complete, cleaned test code with all invalid API request sections\nremoved, ready for compilation. When the draft already successfully\nremoves all problematic code with no additional issues found during\nreview, this value can be null, indicating the draft deletion was\nsufficient and requires no further changes.\n\nThis code must:\n\n- Compile without TypeScript errors\n- Contain only valid business logic tests\n- Have no `as any` or similar type violations\n- Maintain the original file structure\n- Be production-ready E2E test code\n\nA null value indicates the draft successfully removed all invalid code\nand needs no additional modifications.",
+                                    anyOf: [ {
+                                        type: "null"
+                                    }, {
+                                        type: "string"
+                                    } ]
+                                }
+                            },
+                            required: [ "review", "final" ]
+                        }
                     }
-                }
-            },
-            description: "Rewrite function to remove code containing invalid type API requests.\n\nThis function is called when the agent detects code that attempts to send\nAPI requests with deliberately wrong types, causing TypeScript compilation\nerrors. The agent will remove the problematic code sections while\npreserving valid test code.\n\nCommon patterns that trigger this function:\n\n- TestValidator.error calls testing type violations\n- Missing required fields with type assertions\n- Wrong type assignments with satisfies operator\n- Nested type violations in complex objects\n- Partial type testing with invalid structures\n\nThe rationale for deletion:\n\n- Type validation is the server's responsibility, not E2E tests\n- TypeScript compiler should enforce type safety at compile time\n- Invalid type testing breaks the entire test suite compilation\n- E2E tests should focus on business logic, not type system violations",
-            validate: (() => {
-                const _io0 = input => "string" === typeof input.think && "string" === typeof input.draft && ("object" === typeof input.revise && null !== input.revise && _io1(input.revise));
-                const _io1 = input => "string" === typeof input.review && (null === input.final || "string" === typeof input.final);
-                const _vo0 = (input, _path, _exceptionable = true) => [ "string" === typeof input.think || _report(_exceptionable, {
-                    path: _path + ".think",
-                    expected: "string",
-                    value: input.think
-                }), "string" === typeof input.draft || _report(_exceptionable, {
-                    path: _path + ".draft",
-                    expected: "string",
-                    value: input.draft
-                }), ("object" === typeof input.revise && null !== input.revise || _report(_exceptionable, {
-                    path: _path + ".revise",
-                    expected: "IAutoBeTestCorrectInvalidRequestApplication.IReviseProps",
-                    value: input.revise
-                })) && _vo1(input.revise, _path + ".revise", _exceptionable) || _report(_exceptionable, {
-                    path: _path + ".revise",
-                    expected: "IAutoBeTestCorrectInvalidRequestApplication.IReviseProps",
-                    value: input.revise
-                }) ].every(flag => flag);
-                const _vo1 = (input, _path, _exceptionable = true) => [ "string" === typeof input.review || _report(_exceptionable, {
-                    path: _path + ".review",
-                    expected: "string",
-                    value: input.review
-                }), null === input.final || "string" === typeof input.final || _report(_exceptionable, {
-                    path: _path + ".final",
-                    expected: "(null | string)",
-                    value: input.final
-                }) ].every(flag => flag);
-                const __is = input => "object" === typeof input && null !== input && _io0(input);
-                let errors;
-                let _report;
-                return input => {
-                    if (false === __is(input)) {
-                        errors = [];
-                        _report = __typia_transform__validateReport._validateReport(errors);
-                        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
-                            path: _path + "",
-                            expected: "IAutoBeTestCorrectInvalidRequestApplication.IProps",
-                            value: input
-                        })) && _vo0(input, _path + "", true) || _report(true, {
-                            path: _path + "",
-                            expected: "IAutoBeTestCorrectInvalidRequestApplication.IProps",
-                            value: input
-                        }))(input, "$input", true);
-                        const success = 0 === errors.length;
-                        return success ? {
-                            success,
-                            data: input
-                        } : {
-                            success,
-                            errors,
+                },
+                description: "Rewrite function to remove code containing invalid type API requests.\n\nThis function is called when the agent detects code that attempts to send\nAPI requests with deliberately wrong types, causing TypeScript compilation\nerrors. The agent will remove the problematic code sections while\npreserving valid test code.\n\nCommon patterns that trigger this function:\n\n- TestValidator.error calls testing type violations\n- Missing required fields with type assertions\n- Wrong type assignments with satisfies operator\n- Nested type violations in complex objects\n- Partial type testing with invalid structures\n\nThe rationale for deletion:\n\n- Type validation is the server's responsibility, not E2E tests\n- TypeScript compiler should enforce type safety at compile time\n- Invalid type testing breaks the entire test suite compilation\n- E2E tests should focus on business logic, not type system violations",
+                validate: (() => {
+                    const _io0 = input => "string" === typeof input.think && "string" === typeof input.draft && ("object" === typeof input.revise && null !== input.revise && _io1(input.revise));
+                    const _io1 = input => "string" === typeof input.review && (null === input.final || "string" === typeof input.final);
+                    const _vo0 = (input, _path, _exceptionable = true) => [ "string" === typeof input.think || _report(_exceptionable, {
+                        path: _path + ".think",
+                        expected: "string",
+                        value: input.think
+                    }), "string" === typeof input.draft || _report(_exceptionable, {
+                        path: _path + ".draft",
+                        expected: "string",
+                        value: input.draft
+                    }), ("object" === typeof input.revise && null !== input.revise || _report(_exceptionable, {
+                        path: _path + ".revise",
+                        expected: "IAutoBeTestCorrectInvalidRequestApplication.IReviseProps",
+                        value: input.revise
+                    })) && _vo1(input.revise, _path + ".revise", _exceptionable) || _report(_exceptionable, {
+                        path: _path + ".revise",
+                        expected: "IAutoBeTestCorrectInvalidRequestApplication.IReviseProps",
+                        value: input.revise
+                    }) ].every(flag => flag);
+                    const _vo1 = (input, _path, _exceptionable = true) => [ "string" === typeof input.review || _report(_exceptionable, {
+                        path: _path + ".review",
+                        expected: "string",
+                        value: input.review
+                    }), null === input.final || "string" === typeof input.final || _report(_exceptionable, {
+                        path: _path + ".final",
+                        expected: "(null | string)",
+                        value: input.final
+                    }) ].every(flag => flag);
+                    const __is = input => "object" === typeof input && null !== input && _io0(input);
+                    let errors;
+                    let _report;
+                    return input => {
+                        if (false === __is(input)) {
+                            errors = [];
+                            _report = __typia_transform__validateReport._validateReport(errors);
+                            ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
+                                path: _path + "",
+                                expected: "IAutoBeTestCorrectInvalidRequestApplication.IProps",
+                                value: input
+                            })) && _vo0(input, _path + "", true) || _report(true, {
+                                path: _path + "",
+                                expected: "IAutoBeTestCorrectInvalidRequestApplication.IProps",
+                                value: input
+                            }))(input, "$input", true);
+                            const success = 0 === errors.length;
+                            return success ? {
+                                success,
+                                data: input
+                            } : {
+                                success,
+                                errors,
+                                data: input
+                            };
+                        }
+                        return {
+                            success: true,
                             data: input
                         };
-                    }
-                    return {
-                        success: true,
-                        data: input
                     };
-                };
-            })()
-        }, {
-            name: "reject",
-            parameters: {
-                type: "object",
-                properties: {},
-                additionalProperties: false,
-                required: [],
-                $defs: {}
+                })()
+            }, {
+                name: "reject",
+                parameters: {
+                    type: "object",
+                    properties: {},
+                    additionalProperties: false,
+                    required: [],
+                    $defs: {}
+                },
+                description: "Reject function when no invalid type API requests are detected.\n\nThis function is called when the compilation error is not related to\ninvalid API request types, indicating the agent should not intervene.\n\nCommon scenarios for rejection:\n\n- Syntax errors unrelated to type violations\n- Legitimate type mismatches that need fixing (not deletion)\n- Framework-specific compilation issues\n- Configuration or environment problems\n\nWhen called, this indicates that another specialized agent should handle\nthe compilation error, as it's outside this agent's domain.",
+                validate: (() => input => ({
+                    success: true,
+                    data: input
+                }))()
+            } ]
+        };
+        __typia_transform__llmApplicationFinalize._llmApplicationFinalize(application, {
+            ...{
+                validate: {
+                    rewrite: validate,
+                    reject: () => ({
+                        success: true,
+                        data: undefined
+                    })
+                }
             },
-            description: "Reject function when no invalid type API requests are detected.\n\nThis function is called when the compilation error is not related to\ninvalid API request types, indicating the agent should not intervene.\n\nCommon scenarios for rejection:\n\n- Syntax errors unrelated to type violations\n- Legitimate type mismatches that need fixing (not deletion)\n- Framework-specific compilation issues\n- Configuration or environment problems\n\nWhen called, this indicates that another specialized agent should handle\nthe compilation error, as it's outside this agent's domain.",
-            validate: (() => input => ({
-                success: true,
-                data: input
-            }))()
-        } ]
-    },
-    claude: {
-        model: "claude",
-        options: {
-            reference: true,
-            separate: null
-        },
-        functions: [ {
-            name: "rewrite",
-            parameters: {
-                description: " - The analysis and correction properties\n\n------------------------------\n\nDescription of the current {@link IAutoBeTestCorrectInvalidRequestApplication.IProps} type:\n\n> Properties for the rewrite function containing the analysis and correction\n> workflow.\n> \n> This follows a three-phase approach: think → draft → revise, ensuring\n> systematic removal of invalid type testing code while maintaining the\n> integrity of valid E2E tests.",
-                type: "object",
-                properties: {
-                    think: {
-                        description: "Initial analysis phase.\n\nContains the agent's analysis of what specific invalid request pattern\nwas found in the code and how it's causing the compilation error. This\nshould identify:\n\n- The exact pattern (as any, satisfies, TestValidator.error, etc.)\n- Line numbers and locations of violations\n- The TypeScript error codes being triggered\n- Why this constitutes invalid type testing\n\nExample: \"Detected TestValidator.error() call at line 45 with 'as any'\ncasting on request body containing deliberately wrong types (number for\nemail field). This is causing TS2345 compilation error.\"",
-                        type: "string"
-                    },
-                    draft: {
-                        description: "Draft correction phase.\n\nThe initial corrected code with the problematic API request sections\ncompletely removed while preserving all valid test code.\n\nRules for drafting:\n\n- Remove entire test functions containing type violations\n- Do not comment out code - delete it completely\n- Preserve test suite structure and valid tests\n- Maintain proper indentation and formatting\n- Keep imports that are still needed by remaining code",
-                        type: "string"
+            equals: false
+        });
+        return application;
+    })(),
+    claude: validate => (() => {
+        const application = {
+            model: "claude",
+            options: {
+                reference: true,
+                separate: null
+            },
+            functions: [ {
+                name: "rewrite",
+                parameters: {
+                    description: " - The analysis and correction properties\n\n------------------------------\n\nDescription of the current {@link IAutoBeTestCorrectInvalidRequestApplication.IProps} type:\n\n> Properties for the rewrite function containing the analysis and correction\n> workflow.\n> \n> This follows a three-phase approach: think → draft → revise, ensuring\n> systematic removal of invalid type testing code while maintaining the\n> integrity of valid E2E tests.",
+                    type: "object",
+                    properties: {
+                        think: {
+                            description: "Initial analysis phase.\n\nContains the agent's analysis of what specific invalid request pattern\nwas found in the code and how it's causing the compilation error. This\nshould identify:\n\n- The exact pattern (as any, satisfies, TestValidator.error, etc.)\n- Line numbers and locations of violations\n- The TypeScript error codes being triggered\n- Why this constitutes invalid type testing\n\nExample: \"Detected TestValidator.error() call at line 45 with 'as any'\ncasting on request body containing deliberately wrong types (number for\nemail field). This is causing TS2345 compilation error.\"",
+                            type: "string"
+                        },
+                        draft: {
+                            description: "Draft correction phase.\n\nThe initial corrected code with the problematic API request sections\ncompletely removed while preserving all valid test code.\n\nRules for drafting:\n\n- Remove entire test functions containing type violations\n- Do not comment out code - delete it completely\n- Preserve test suite structure and valid tests\n- Maintain proper indentation and formatting\n- Keep imports that are still needed by remaining code",
+                            type: "string"
+                        },
+                        revise: {
+                            description: "Review and finalization phase.\n\nContains the review of changes made and the final cleaned code that\nshould compile without the invalid API request errors. This ensures the\ncorrection is complete and accurate.",
+                            $ref: "#/$defs/IAutoBeTestCorrectInvalidRequestApplication.IReviseProps"
+                        }
                     },
-                    revise: {
-                        description: "Review and finalization phase.\n\nContains the review of changes made and the final cleaned code that\nshould compile without the invalid API request errors. This ensures the\ncorrection is complete and accurate.",
-                        $ref: "#/$defs/IAutoBeTestCorrectInvalidRequestApplication.IReviseProps"
-                    }
-                },
-                required: [ "think", "draft", "revise" ],
-                additionalProperties: false,
-                $defs: {
-                    "IAutoBeTestCorrectInvalidRequestApplication.IReviseProps": {
-                        description: "Properties for the revision phase of the correction process.\n\nThis phase ensures that the removal was complete and the remaining code is\nvalid and compilable.",
-                        type: "object",
-                        properties: {
-                            review: {
-                                description: 'Review of the changes made.\n\nBrief explanation of what invalid API request code was removed and\nverification that valid test code was preserved. Should confirm:\n\n- Which patterns were found and removed\n- Line ranges that were deleted\n- Verification that valid tests remain intact\n- Confirmation that no partial fixes were applied\n\nExample: "Removed lines 43-52 containing TestValidator.error with invalid\ntype casting. Verified remaining tests are valid and unaffected."',
-                                type: "string"
-                            },
-                            final: {
-                                description: "Final corrected code.\n\nThe complete, cleaned test code with all invalid API request sections\nremoved, ready for compilation. When the draft already successfully\nremoves all problematic code with no additional issues found during\nreview, this value can be null, indicating the draft deletion was\nsufficient and requires no further changes.\n\nThis code must:\n\n- Compile without TypeScript errors\n- Contain only valid business logic tests\n- Have no `as any` or similar type violations\n- Maintain the original file structure\n- Be production-ready E2E test code\n\nA null value indicates the draft successfully removed all invalid code\nand needs no additional modifications.",
-                                oneOf: [ {
-                                    type: "null"
-                                }, {
+                    required: [ "think", "draft", "revise" ],
+                    additionalProperties: false,
+                    $defs: {
+                        "IAutoBeTestCorrectInvalidRequestApplication.IReviseProps": {
+                            description: "Properties for the revision phase of the correction process.\n\nThis phase ensures that the removal was complete and the remaining code is\nvalid and compilable.",
+                            type: "object",
+                            properties: {
+                                review: {
+                                    description: 'Review of the changes made.\n\nBrief explanation of what invalid API request code was removed and\nverification that valid test code was preserved. Should confirm:\n\n- Which patterns were found and removed\n- Line ranges that were deleted\n- Verification that valid tests remain intact\n- Confirmation that no partial fixes were applied\n\nExample: "Removed lines 43-52 containing TestValidator.error with invalid\ntype casting. Verified remaining tests are valid and unaffected."',
                                     type: "string"
-                                } ]
-                            }
-                        },
-                        required: [ "review", "final" ]
+                                },
+                                final: {
+                                    description: "Final corrected code.\n\nThe complete, cleaned test code with all invalid API request sections\nremoved, ready for compilation. When the draft already successfully\nremoves all problematic code with no additional issues found during\nreview, this value can be null, indicating the draft deletion was\nsufficient and requires no further changes.\n\nThis code must:\n\n- Compile without TypeScript errors\n- Contain only valid business logic tests\n- Have no `as any` or similar type violations\n- Maintain the original file structure\n- Be production-ready E2E test code\n\nA null value indicates the draft successfully removed all invalid code\nand needs no additional modifications.",
+                                    oneOf: [ {
+                                        type: "null"
+                                    }, {
+                                        type: "string"
+                                    } ]
+                                }
+                            },
+                            required: [ "review", "final" ]
+                        }
                     }
-                }
-            },
-            description: "Rewrite function to remove code containing invalid type API requests.\n\nThis function is called when the agent detects code that attempts to send\nAPI requests with deliberately wrong types, causing TypeScript compilation\nerrors. The agent will remove the problematic code sections while\npreserving valid test code.\n\nCommon patterns that trigger this function:\n\n- TestValidator.error calls testing type violations\n- Missing required fields with type assertions\n- Wrong type assignments with satisfies operator\n- Nested type violations in complex objects\n- Partial type testing with invalid structures\n\nThe rationale for deletion:\n\n- Type validation is the server's responsibility, not E2E tests\n- TypeScript compiler should enforce type safety at compile time\n- Invalid type testing breaks the entire test suite compilation\n- E2E tests should focus on business logic, not type system violations",
-            validate: (() => {
-                const _io0 = input => "string" === typeof input.think && "string" === typeof input.draft && ("object" === typeof input.revise && null !== input.revise && _io1(input.revise));
-                const _io1 = input => "string" === typeof input.review && (null === input.final || "string" === typeof input.final);
-                const _vo0 = (input, _path, _exceptionable = true) => [ "string" === typeof input.think || _report(_exceptionable, {
-                    path: _path + ".think",
-                    expected: "string",
-                    value: input.think
-                }), "string" === typeof input.draft || _report(_exceptionable, {
-                    path: _path + ".draft",
-                    expected: "string",
-                    value: input.draft
-                }), ("object" === typeof input.revise && null !== input.revise || _report(_exceptionable, {
-                    path: _path + ".revise",
-                    expected: "IAutoBeTestCorrectInvalidRequestApplication.IReviseProps",
-                    value: input.revise
-                })) && _vo1(input.revise, _path + ".revise", _exceptionable) || _report(_exceptionable, {
-                    path: _path + ".revise",
-                    expected: "IAutoBeTestCorrectInvalidRequestApplication.IReviseProps",
-                    value: input.revise
-                }) ].every(flag => flag);
-                const _vo1 = (input, _path, _exceptionable = true) => [ "string" === typeof input.review || _report(_exceptionable, {
-                    path: _path + ".review",
-                    expected: "string",
-                    value: input.review
-                }), null === input.final || "string" === typeof input.final || _report(_exceptionable, {
-                    path: _path + ".final",
-                    expected: "(null | string)",
-                    value: input.final
-                }) ].every(flag => flag);
-                const __is = input => "object" === typeof input && null !== input && _io0(input);
-                let errors;
-                let _report;
-                return input => {
-                    if (false === __is(input)) {
-                        errors = [];
-                        _report = __typia_transform__validateReport._validateReport(errors);
-                        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
-                            path: _path + "",
-                            expected: "IAutoBeTestCorrectInvalidRequestApplication.IProps",
-                            value: input
-                        })) && _vo0(input, _path + "", true) || _report(true, {
-                            path: _path + "",
-                            expected: "IAutoBeTestCorrectInvalidRequestApplication.IProps",
-                            value: input
-                        }))(input, "$input", true);
-                        const success = 0 === errors.length;
-                        return success ? {
-                            success,
-                            data: input
-                        } : {
-                            success,
-                            errors,
+                },
+                description: "Rewrite function to remove code containing invalid type API requests.\n\nThis function is called when the agent detects code that attempts to send\nAPI requests with deliberately wrong types, causing TypeScript compilation\nerrors. The agent will remove the problematic code sections while\npreserving valid test code.\n\nCommon patterns that trigger this function:\n\n- TestValidator.error calls testing type violations\n- Missing required fields with type assertions\n- Wrong type assignments with satisfies operator\n- Nested type violations in complex objects\n- Partial type testing with invalid structures\n\nThe rationale for deletion:\n\n- Type validation is the server's responsibility, not E2E tests\n- TypeScript compiler should enforce type safety at compile time\n- Invalid type testing breaks the entire test suite compilation\n- E2E tests should focus on business logic, not type system violations",
+                validate: (() => {
+                    const _io0 = input => "string" === typeof input.think && "string" === typeof input.draft && ("object" === typeof input.revise && null !== input.revise && _io1(input.revise));
+                    const _io1 = input => "string" === typeof input.review && (null === input.final || "string" === typeof input.final);
+                    const _vo0 = (input, _path, _exceptionable = true) => [ "string" === typeof input.think || _report(_exceptionable, {
+                        path: _path + ".think",
+                        expected: "string",
+                        value: input.think
+                    }), "string" === typeof input.draft || _report(_exceptionable, {
+                        path: _path + ".draft",
+                        expected: "string",
+                        value: input.draft
+                    }), ("object" === typeof input.revise && null !== input.revise || _report(_exceptionable, {
+                        path: _path + ".revise",
+                        expected: "IAutoBeTestCorrectInvalidRequestApplication.IReviseProps",
+                        value: input.revise
+                    })) && _vo1(input.revise, _path + ".revise", _exceptionable) || _report(_exceptionable, {
+                        path: _path + ".revise",
+                        expected: "IAutoBeTestCorrectInvalidRequestApplication.IReviseProps",
+                        value: input.revise
+                    }) ].every(flag => flag);
+                    const _vo1 = (input, _path, _exceptionable = true) => [ "string" === typeof input.review || _report(_exceptionable, {
+                        path: _path + ".review",
+                        expected: "string",
+                        value: input.review
+                    }), null === input.final || "string" === typeof input.final || _report(_exceptionable, {
+                        path: _path + ".final",
+                        expected: "(null | string)",
+                        value: input.final
+                    }) ].every(flag => flag);
+                    const __is = input => "object" === typeof input && null !== input && _io0(input);
+                    let errors;
+                    let _report;
+                    return input => {
+                        if (false === __is(input)) {
+                            errors = [];
+                            _report = __typia_transform__validateReport._validateReport(errors);
+                            ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
+                                path: _path + "",
+                                expected: "IAutoBeTestCorrectInvalidRequestApplication.IProps",
+                                value: input
+                            })) && _vo0(input, _path + "", true) || _report(true, {
+                                path: _path + "",
+                                expected: "IAutoBeTestCorrectInvalidRequestApplication.IProps",
+                                value: input
+                            }))(input, "$input", true);
+                            const success = 0 === errors.length;
+                            return success ? {
+                                success,
+                                data: input
+                            } : {
+                                success,
+                                errors,
+                                data: input
+                            };
+                        }
+                        return {
+                            success: true,
                             data: input
                         };
-                    }
-                    return {
-                        success: true,
-                        data: input
                     };
-                };
-            })()
-        }, {
-            name: "reject",
-            parameters: {
-                type: "object",
-                properties: {},
-                additionalProperties: false,
-                required: [],
-                $defs: {}
+                })()
+            }, {
+                name: "reject",
+                parameters: {
+                    type: "object",
+                    properties: {},
+                    additionalProperties: false,
+                    required: [],
+                    $defs: {}
+                },
+                description: "Reject function when no invalid type API requests are detected.\n\nThis function is called when the compilation error is not related to\ninvalid API request types, indicating the agent should not intervene.\n\nCommon scenarios for rejection:\n\n- Syntax errors unrelated to type violations\n- Legitimate type mismatches that need fixing (not deletion)\n- Framework-specific compilation issues\n- Configuration or environment problems\n\nWhen called, this indicates that another specialized agent should handle\nthe compilation error, as it's outside this agent's domain.",
+                validate: (() => input => ({
+                    success: true,
+                    data: input
+                }))()
+            } ]
+        };
+        __typia_transform__llmApplicationFinalize._llmApplicationFinalize(application, {
+            ...{
+                validate: {
+                    rewrite: validate,
+                    reject: () => ({
+                        success: true,
+                        data: undefined
+                    })
+                }
             },
-            description: "Reject function when no invalid type API requests are detected.\n\nThis function is called when the compilation error is not related to\ninvalid API request types, indicating the agent should not intervene.\n\nCommon scenarios for rejection:\n\n- Syntax errors unrelated to type violations\n- Legitimate type mismatches that need fixing (not deletion)\n- Framework-specific compilation issues\n- Configuration or environment problems\n\nWhen called, this indicates that another specialized agent should handle\nthe compilation error, as it's outside this agent's domain.",
-            validate: (() => input => ({
-                success: true,
-                data: input
-            }))()
-        } ]
-    }
+            equals: false
+        });
+        return application;
+    })()
 };
 
 const orchestrateTestCorrect = async (ctx, props) => {
@@ -29601,7 +30128,8 @@ const orchestrateTestCorrect = async (ctx, props) => {
                     final: next.final,
                     step: ctx.state().analyze?.step ?? 0
                 }),
-                script: event => event.file.content
+                script: event => event.file.content,
+                functionName: w.scenario.functionName
             }, x.file.content);
             return await predicate(ctx, {
                 function: transformTestValidateEvent(y, w.artifacts),
@@ -29662,6 +30190,7 @@ const correct = async (ctx, props, life) => {
         }),
         controller: createController$3({
             model: ctx.model,
+            functionName: props.function.scenario.functionName,
             failure: props.validate.result,
             build: next => {
                 pointer.value = next;
@@ -29773,7 +30302,17 @@ const createController$3 = props => {
                 };
             };
         })()(input);
-        return result;
+        if (result.success === false) return result;
+        const errors = validateEmptyCode({
+            functionName: props.functionName,
+            draft: result.data.draft,
+            revise: result.data.revise
+        });
+        return errors.length ? {
+            success: false,
+            errors,
+            data: result.data
+        } : result;
     };
     const application = collection$4[props.model === "chatgpt" ? "chatgpt" : "claude"](validate);
     return {
@@ -31987,6 +32526,7 @@ async function process(ctx, props) {
         }),
         controller: createController({
             model: ctx.model,
+            functionName: props.scenario.functionName,
             build: next => {
                 next.domain = NamingConvention.snake(next.domain);
                 pointer.value = next;
@@ -32021,73 +32561,8 @@ async function process(ctx, props) {
 
 function createController(props) {
     assertSchemaModel(props.model);
-    const application = collection$1[props.model];
-    return {
-        protocol: "class",
-        name: "Create Test Code",
-        application,
-        execute: {
-            write: next => {
-                props.build(next);
-            }
-        }
-    };
-}
-
-const claude$1 = {
-    model: "claude",
-    options: {
-        reference: true,
-        separate: null
-    },
-    functions: [ {
-        name: "write",
-        parameters: {
-            description: " Complete specification for test generation including scenario,\ndomain, and implementation steps\n\n------------------------------\n\nCurrent Type: {@link IAutoBeTestWriteApplication.IProps}",
-            type: "object",
-            properties: {
-                scenario: {
-                    description: "Step 1: Strategic test planning and scenario analysis.\n\nAI analyzes the given test scenario and creates a comprehensive\nimplementation strategy. This planning phase is crucial for generating\nwell-structured, maintainable test code. The AI must define test\nmethodology, data preparation, execution flow, and validation logic\nbefore proceeding to code implementation.\n\nWorkflow: Input scenario → Strategic analysis → Detailed test plan",
-                    type: "string"
-                },
-                domain: {
-                    description: "Step 2: Functional domain classification for test organization.\n\nAI determines the appropriate domain category based on the scenario\nanalysis. This classification drives file structure, test categorization,\nand logical grouping. The domain must be a single, lowercase word in\nsnake_case format that represents the primary API resource.\n\nWorkflow: Scenario analysis → Domain identification → Test organization\nstructure",
-                    type: "string"
-                },
-                draft: {
-                    description: "Step 3: Initial TypeScript E2E test code implementation.\n\nAI generates the first working version of the test code based on the\nstrategic plan. This draft must be compilation-error-free and follow",
-                    type: "string"
-                },
-                revise: {
-                    description: "Steps 4-5: Code review and final refinement process.\n\nContains the iterative improvement workflow that transforms the initial\ndraft into production-ready test code. The review phase identifies issues\nto fix or code to delete, followed by the final phase that produces the\npolished, production-ready test implementation.\n\nWorkflow: Draft → Review analysis → Final implementation",
-                    $ref: "#/$defs/IAutoBeTestWriteApplication.IReviseProps"
-                }
-            },
-            required: [ "scenario", "domain", "draft", "revise" ],
-            additionalProperties: false,
-            $defs: {
-                "IAutoBeTestWriteApplication.IReviseProps": {
-                    type: "object",
-                    properties: {
-                        review: {
-                            description: "Step 4: Code review and quality assessment.\n\n**🚨 TWO TYPES OF REVISIONS: FIX AND DELETE 🚨**\n\nAI performs a thorough review of the draft implementation for:\n\n**1. FIX - Improve existing code:**\n\n**Compilation & Syntax:**\n\n- TypeScript compilation errors and type mismatches\n- Syntax errors and missing semicolons/brackets\n- Correct function signatures and parameter types\n\n**Framework Compliance:**\n\n-",
-                            type: "string"
-                        },
-                        final: {
-                            description: "Step 5: Final production-ready test code.\n\nAI produces the final, polished version of the test code incorporating\nall review feedback. This code represents the completed test\nimplementation, ready for production deployment. When the draft code is\nalready perfect with no issues found during review, this value can be\nnull, indicating no revisions were necessary.\n\n**🚨 CRITICAL: APPLY ALL FIXES AND DELETIONS FROM REVIEW 🚨**\n\n- FIX all correctable issues identified in review\n- DELETE all prohibited code identified in review\n- If review found type error tests, they MUST be deleted in final\n- If review found code to DELETE, final MUST be different from draft\n- If review finds NO issues requiring changes, set to null\n\nAll identified issues must be resolved, and the code must meet the\nhighest quality standards. A null value indicates the draft code already\nmeets all requirements without modification.\n\nWorkflow: Review feedback → Apply FIXES → Apply DELETIONS →\nProduction-ready implementation (or null if no changes needed)\n\nThis is the ultimate deliverable that will be used in the actual test\nsuite when provided, otherwise the draft is used as-is.",
-                            oneOf: [ {
-                                type: "null"
-                            }, {
-                                type: "string"
-                            } ]
-                        }
-                    },
-                    required: [ "review", "final" ]
-                }
-            }
-        },
-        description: "Main entry point for AI Function Call - generates complete E2E test code.\n\nThe AI executes this function to perform the entire test generation\nworkflow: scenario analysis → draft implementation → code review → final\ncode production. This structured approach ensures high-quality,\ncompilation-error-free test code.",
-        validate: (() => {
+    const validate = input => {
+        const result = (() => {
             const _io0 = input => "string" === typeof input.scenario && "string" === typeof input.domain && "string" === typeof input.draft && ("object" === typeof input.revise && null !== input.revise && _io1(input.revise));
             const _io1 = input => "string" === typeof input.review && (null === input.final || "string" === typeof input.final);
             const _vo0 = (input, _path, _exceptionable = true) => [ "string" === typeof input.scenario || _report(_exceptionable, {
@@ -32151,249 +32626,295 @@ const claude$1 = {
                     data: input
                 };
             };
-        })()
-    } ]
-};
+        })()(input);
+        if (result.success === false) return result;
+        const errors = validateEmptyCode({
+            functionName: props.functionName,
+            draft: result.data.draft,
+            revise: result.data.revise
+        });
+        return errors.length ? {
+            success: false,
+            errors,
+            data: result.data
+        } : result;
+    };
+    const application = collection$1[props.model === "chatgpt" ? "chatgpt" : "claude"](validate);
+    return {
+        protocol: "class",
+        name: "Create Test Code",
+        application,
+        execute: {
+            write: next => {
+                props.build(next);
+            }
+        }
+    };
+}
 
 const collection$1 = {
-    chatgpt: {
-        model: "chatgpt",
-        options: {
-            reference: true,
-            strict: false,
-            separate: null
-        },
-        functions: [ {
-            name: "write",
-            parameters: {
-                description: " Complete specification for test generation including scenario,\ndomain, and implementation steps\n\n------------------------------\n\nCurrent Type: {@link IAutoBeTestWriteApplication.IProps}\n\n### Description of {@link revise} property:\n\n> Steps 4-5: Code review and final refinement process.\n> \n> Contains the iterative improvement workflow that transforms the initial\n> draft into production-ready test code. The review phase identifies issues\n> to fix or code to delete, followed by the final phase that produces the\n> polished, production-ready test implementation.\n> \n> Workflow: Draft → Review analysis → Final implementation",
-                type: "object",
-                properties: {
-                    scenario: {
-                        description: "Step 1: Strategic test planning and scenario analysis.\n\nAI analyzes the given test scenario and creates a comprehensive\nimplementation strategy. This planning phase is crucial for generating\nwell-structured, maintainable test code. The AI must define test\nmethodology, data preparation, execution flow, and validation logic\nbefore proceeding to code implementation.\n\nWorkflow: Input scenario → Strategic analysis → Detailed test plan",
-                        type: "string"
-                    },
-                    domain: {
-                        description: "Step 2: Functional domain classification for test organization.\n\nAI determines the appropriate domain category based on the scenario\nanalysis. This classification drives file structure, test categorization,\nand logical grouping. The domain must be a single, lowercase word in\nsnake_case format that represents the primary API resource.\n\nWorkflow: Scenario analysis → Domain identification → Test organization\nstructure",
-                        type: "string"
-                    },
-                    draft: {
-                        description: "Step 3: Initial TypeScript E2E test code implementation.\n\nAI generates the first working version of the test code based on the\nstrategic plan. This draft must be compilation-error-free and follow",
-                        type: "string"
+    chatgpt: validate => (() => {
+        const application = {
+            model: "chatgpt",
+            options: {
+                reference: true,
+                strict: false,
+                separate: null
+            },
+            functions: [ {
+                name: "write",
+                parameters: {
+                    description: " Complete specification for test generation including scenario,\ndomain, and implementation steps\n\n------------------------------\n\nCurrent Type: {@link IAutoBeTestWriteApplication.IProps}\n\n### Description of {@link revise} property:\n\n> Steps 4-5: Code review and final refinement process.\n> \n> Contains the iterative improvement workflow that transforms the initial\n> draft into production-ready test code. The review phase identifies issues\n> to fix or code to delete, followed by the final phase that produces the\n> polished, production-ready test implementation.\n> \n> Workflow: Draft → Review analysis → Final implementation",
+                    type: "object",
+                    properties: {
+                        scenario: {
+                            description: "Step 1: Strategic test planning and scenario analysis.\n\nAI analyzes the given test scenario and creates a comprehensive\nimplementation strategy. This planning phase is crucial for generating\nwell-structured, maintainable test code. The AI must define test\nmethodology, data preparation, execution flow, and validation logic\nbefore proceeding to code implementation.\n\nWorkflow: Input scenario → Strategic analysis → Detailed test plan",
+                            type: "string"
+                        },
+                        domain: {
+                            description: "Step 2: Functional domain classification for test organization.\n\nAI determines the appropriate domain category based on the scenario\nanalysis. This classification drives file structure, test categorization,\nand logical grouping. The domain must be a single, lowercase word in\nsnake_case format that represents the primary API resource.\n\nWorkflow: Scenario analysis → Domain identification → Test organization\nstructure",
+                            type: "string"
+                        },
+                        draft: {
+                            description: "Step 3: Initial TypeScript E2E test code implementation.\n\nAI generates the first working version of the test code based on the\nstrategic plan. This draft must be compilation-error-free and follow",
+                            type: "string"
+                        },
+                        revise: {
+                            $ref: "#/$defs/IAutoBeTestWriteApplication.IReviseProps"
+                        }
                     },
-                    revise: {
-                        $ref: "#/$defs/IAutoBeTestWriteApplication.IReviseProps"
-                    }
-                },
-                required: [ "scenario", "domain", "draft", "revise" ],
-                additionalProperties: false,
-                $defs: {
-                    "IAutoBeTestWriteApplication.IReviseProps": {
-                        type: "object",
-                        properties: {
-                            review: {
-                                description: "Step 4: Code review and quality assessment.\n\n**🚨 TWO TYPES OF REVISIONS: FIX AND DELETE 🚨**\n\nAI performs a thorough review of the draft implementation for:\n\n**1. FIX - Improve existing code:**\n\n**Compilation & Syntax:**\n\n- TypeScript compilation errors and type mismatches\n- Syntax errors and missing semicolons/brackets\n- Correct function signatures and parameter types\n\n**Framework Compliance:**\n\n-",
-                                type: "string"
-                            },
-                            final: {
-                                description: "Step 5: Final production-ready test code.\n\nAI produces the final, polished version of the test code incorporating\nall review feedback. This code represents the completed test\nimplementation, ready for production deployment. When the draft code is\nalready perfect with no issues found during review, this value can be\nnull, indicating no revisions were necessary.\n\n**🚨 CRITICAL: APPLY ALL FIXES AND DELETIONS FROM REVIEW 🚨**\n\n- FIX all correctable issues identified in review\n- DELETE all prohibited code identified in review\n- If review found type error tests, they MUST be deleted in final\n- If review found code to DELETE, final MUST be different from draft\n- If review finds NO issues requiring changes, set to null\n\nAll identified issues must be resolved, and the code must meet the\nhighest quality standards. A null value indicates the draft code already\nmeets all requirements without modification.\n\nWorkflow: Review feedback → Apply FIXES → Apply DELETIONS →\nProduction-ready implementation (or null if no changes needed)\n\nThis is the ultimate deliverable that will be used in the actual test\nsuite when provided, otherwise the draft is used as-is.",
-                                anyOf: [ {
-                                    type: "null"
-                                }, {
+                    required: [ "scenario", "domain", "draft", "revise" ],
+                    additionalProperties: false,
+                    $defs: {
+                        "IAutoBeTestWriteApplication.IReviseProps": {
+                            type: "object",
+                            properties: {
+                                review: {
+                                    description: "Step 4: Code review and quality assessment.\n\n**🚨 TWO TYPES OF REVISIONS: FIX AND DELETE 🚨**\n\nAI performs a thorough review of the draft implementation for:\n\n**1. FIX - Improve existing code:**\n\n**Compilation & Syntax:**\n\n- TypeScript compilation errors and type mismatches\n- Syntax errors and missing semicolons/brackets\n- Correct function signatures and parameter types\n\n**Framework Compliance:**\n\n-",
                                     type: "string"
-                                } ]
-                            }
-                        },
-                        required: [ "review", "final" ]
+                                },
+                                final: {
+                                    description: "Step 5: Final production-ready test code.\n\nAI produces the final, polished version of the test code incorporating\nall review feedback. This code represents the completed test\nimplementation, ready for production deployment. When the draft code is\nalready perfect with no issues found during review, this value can be\nnull, indicating no revisions were necessary.\n\n**🚨 CRITICAL: APPLY ALL FIXES AND DELETIONS FROM REVIEW 🚨**\n\n- FIX all correctable issues identified in review\n- DELETE all prohibited code identified in review\n- If review found type error tests, they MUST be deleted in final\n- If review found code to DELETE, final MUST be different from draft\n- If review finds NO issues requiring changes, set to null\n\nAll identified issues must be resolved, and the code must meet the\nhighest quality standards. A null value indicates the draft code already\nmeets all requirements without modification.\n\nWorkflow: Review feedback → Apply FIXES → Apply DELETIONS →\nProduction-ready implementation (or null if no changes needed)\n\nThis is the ultimate deliverable that will be used in the actual test\nsuite when provided, otherwise the draft is used as-is.",
+                                    anyOf: [ {
+                                        type: "null"
+                                    }, {
+                                        type: "string"
+                                    } ]
+                                }
+                            },
+                            required: [ "review", "final" ]
+                        }
                     }
-                }
-            },
-            description: "Main entry point for AI Function Call - generates complete E2E test code.\n\nThe AI executes this function to perform the entire test generation\nworkflow: scenario analysis → draft implementation → code review → final\ncode production. This structured approach ensures high-quality,\ncompilation-error-free test code.",
-            validate: (() => {
-                const _io0 = input => "string" === typeof input.scenario && "string" === typeof input.domain && "string" === typeof input.draft && ("object" === typeof input.revise && null !== input.revise && _io1(input.revise));
-                const _io1 = input => "string" === typeof input.review && (null === input.final || "string" === typeof input.final);
-                const _vo0 = (input, _path, _exceptionable = true) => [ "string" === typeof input.scenario || _report(_exceptionable, {
-                    path: _path + ".scenario",
-                    expected: "string",
-                    value: input.scenario
-                }), "string" === typeof input.domain || _report(_exceptionable, {
-                    path: _path + ".domain",
-                    expected: "string",
-                    value: input.domain
-                }), "string" === typeof input.draft || _report(_exceptionable, {
-                    path: _path + ".draft",
-                    expected: "string",
-                    value: input.draft
-                }), ("object" === typeof input.revise && null !== input.revise || _report(_exceptionable, {
-                    path: _path + ".revise",
-                    expected: "IAutoBeTestWriteApplication.IReviseProps",
-                    value: input.revise
-                })) && _vo1(input.revise, _path + ".revise", _exceptionable) || _report(_exceptionable, {
-                    path: _path + ".revise",
-                    expected: "IAutoBeTestWriteApplication.IReviseProps",
-                    value: input.revise
-                }) ].every(flag => flag);
-                const _vo1 = (input, _path, _exceptionable = true) => [ "string" === typeof input.review || _report(_exceptionable, {
-                    path: _path + ".review",
-                    expected: "string",
-                    value: input.review
-                }), null === input.final || "string" === typeof input.final || _report(_exceptionable, {
-                    path: _path + ".final",
-                    expected: "(null | string)",
-                    value: input.final
-                }) ].every(flag => flag);
-                const __is = input => "object" === typeof input && null !== input && _io0(input);
-                let errors;
-                let _report;
-                return input => {
-                    if (false === __is(input)) {
-                        errors = [];
-                        _report = __typia_transform__validateReport._validateReport(errors);
-                        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
-                            path: _path + "",
-                            expected: "IAutoBeTestWriteApplication.IProps",
-                            value: input
-                        })) && _vo0(input, _path + "", true) || _report(true, {
-                            path: _path + "",
-                            expected: "IAutoBeTestWriteApplication.IProps",
-                            value: input
-                        }))(input, "$input", true);
-                        const success = 0 === errors.length;
-                        return success ? {
-                            success,
-                            data: input
-                        } : {
-                            success,
-                            errors,
+                },
+                description: "Main entry point for AI Function Call - generates complete E2E test code.\n\nThe AI executes this function to perform the entire test generation\nworkflow: scenario analysis → draft implementation → code review → final\ncode production. This structured approach ensures high-quality,\ncompilation-error-free test code.",
+                validate: (() => {
+                    const _io0 = input => "string" === typeof input.scenario && "string" === typeof input.domain && "string" === typeof input.draft && ("object" === typeof input.revise && null !== input.revise && _io1(input.revise));
+                    const _io1 = input => "string" === typeof input.review && (null === input.final || "string" === typeof input.final);
+                    const _vo0 = (input, _path, _exceptionable = true) => [ "string" === typeof input.scenario || _report(_exceptionable, {
+                        path: _path + ".scenario",
+                        expected: "string",
+                        value: input.scenario
+                    }), "string" === typeof input.domain || _report(_exceptionable, {
+                        path: _path + ".domain",
+                        expected: "string",
+                        value: input.domain
+                    }), "string" === typeof input.draft || _report(_exceptionable, {
+                        path: _path + ".draft",
+                        expected: "string",
+                        value: input.draft
+                    }), ("object" === typeof input.revise && null !== input.revise || _report(_exceptionable, {
+                        path: _path + ".revise",
+                        expected: "IAutoBeTestWriteApplication.IReviseProps",
+                        value: input.revise
+                    })) && _vo1(input.revise, _path + ".revise", _exceptionable) || _report(_exceptionable, {
+                        path: _path + ".revise",
+                        expected: "IAutoBeTestWriteApplication.IReviseProps",
+                        value: input.revise
+                    }) ].every(flag => flag);
+                    const _vo1 = (input, _path, _exceptionable = true) => [ "string" === typeof input.review || _report(_exceptionable, {
+                        path: _path + ".review",
+                        expected: "string",
+                        value: input.review
+                    }), null === input.final || "string" === typeof input.final || _report(_exceptionable, {
+                        path: _path + ".final",
+                        expected: "(null | string)",
+                        value: input.final
+                    }) ].every(flag => flag);
+                    const __is = input => "object" === typeof input && null !== input && _io0(input);
+                    let errors;
+                    let _report;
+                    return input => {
+                        if (false === __is(input)) {
+                            errors = [];
+                            _report = __typia_transform__validateReport._validateReport(errors);
+                            ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
+                                path: _path + "",
+                                expected: "IAutoBeTestWriteApplication.IProps",
+                                value: input
+                            })) && _vo0(input, _path + "", true) || _report(true, {
+                                path: _path + "",
+                                expected: "IAutoBeTestWriteApplication.IProps",
+                                value: input
+                            }))(input, "$input", true);
+                            const success = 0 === errors.length;
+                            return success ? {
+                                success,
+                                data: input
+                            } : {
+                                success,
+                                errors,
+                                data: input
+                            };
+                        }
+                        return {
+                            success: true,
                             data: input
                         };
-                    }
-                    return {
-                        success: true,
-                        data: input
                     };
-                };
-            })()
-        } ]
-    },
-    claude: claude$1,
-    llama: claude$1,
-    deepseek: claude$1,
-    3.1: claude$1,
-    "3.0": {
-        model: "3.0",
-        options: {
-            recursive: 3,
-            constraint: true,
-            separate: null
-        },
-        functions: [ {
-            name: "write",
-            parameters: {
-                type: "object",
-                properties: {
-                    scenario: {
-                        type: "string",
-                        description: "Step 1: Strategic test planning and scenario analysis.\n\nAI analyzes the given test scenario and creates a comprehensive\nimplementation strategy. This planning phase is crucial for generating\nwell-structured, maintainable test code. The AI must define test\nmethodology, data preparation, execution flow, and validation logic\nbefore proceeding to code implementation.\n\nWorkflow: Input scenario → Strategic analysis → Detailed test plan"
-                    },
-                    domain: {
-                        type: "string",
-                        description: "Step 2: Functional domain classification for test organization.\n\nAI determines the appropriate domain category based on the scenario\nanalysis. This classification drives file structure, test categorization,\nand logical grouping. The domain must be a single, lowercase word in\nsnake_case format that represents the primary API resource.\n\nWorkflow: Scenario analysis → Domain identification → Test organization\nstructure"
-                    },
-                    draft: {
-                        type: "string",
-                        description: "Step 3: Initial TypeScript E2E test code implementation.\n\nAI generates the first working version of the test code based on the\nstrategic plan. This draft must be compilation-error-free and follow"
+                })()
+            } ]
+        };
+        __typia_transform__llmApplicationFinalize._llmApplicationFinalize(application, {
+            ...{
+                validate: {
+                    write: validate
+                }
+            },
+            equals: false
+        });
+        return application;
+    })(),
+    claude: validate => (() => {
+        const application = {
+            model: "claude",
+            options: {
+                reference: true,
+                separate: null
+            },
+            functions: [ {
+                name: "write",
+                parameters: {
+                    description: " Complete specification for test generation including scenario,\ndomain, and implementation steps\n\n------------------------------\n\nCurrent Type: {@link IAutoBeTestWriteApplication.IProps}",
+                    type: "object",
+                    properties: {
+                        scenario: {
+                            description: "Step 1: Strategic test planning and scenario analysis.\n\nAI analyzes the given test scenario and creates a comprehensive\nimplementation strategy. This planning phase is crucial for generating\nwell-structured, maintainable test code. The AI must define test\nmethodology, data preparation, execution flow, and validation logic\nbefore proceeding to code implementation.\n\nWorkflow: Input scenario → Strategic analysis → Detailed test plan",
+                            type: "string"
+                        },
+                        domain: {
+                            description: "Step 2: Functional domain classification for test organization.\n\nAI determines the appropriate domain category based on the scenario\nanalysis. This classification drives file structure, test categorization,\nand logical grouping. The domain must be a single, lowercase word in\nsnake_case format that represents the primary API resource.\n\nWorkflow: Scenario analysis → Domain identification → Test organization\nstructure",
+                            type: "string"
+                        },
+                        draft: {
+                            description: "Step 3: Initial TypeScript E2E test code implementation.\n\nAI generates the first working version of the test code based on the\nstrategic plan. This draft must be compilation-error-free and follow",
+                            type: "string"
+                        },
+                        revise: {
+                            description: "Steps 4-5: Code review and final refinement process.\n\nContains the iterative improvement workflow that transforms the initial\ndraft into production-ready test code. The review phase identifies issues\nto fix or code to delete, followed by the final phase that produces the\npolished, production-ready test implementation.\n\nWorkflow: Draft → Review analysis → Final implementation",
+                            $ref: "#/$defs/IAutoBeTestWriteApplication.IReviseProps"
+                        }
                     },
-                    revise: {
-                        type: "object",
-                        properties: {
-                            review: {
-                                type: "string",
-                                description: "Step 4: Code review and quality assessment.\n\n**🚨 TWO TYPES OF REVISIONS: FIX AND DELETE 🚨**\n\nAI performs a thorough review of the draft implementation for:\n\n**1. FIX - Improve existing code:**\n\n**Compilation & Syntax:**\n\n- TypeScript compilation errors and type mismatches\n- Syntax errors and missing semicolons/brackets\n- Correct function signatures and parameter types\n\n**Framework Compliance:**\n\n-"
+                    required: [ "scenario", "domain", "draft", "revise" ],
+                    additionalProperties: false,
+                    $defs: {
+                        "IAutoBeTestWriteApplication.IReviseProps": {
+                            type: "object",
+                            properties: {
+                                review: {
+                                    description: "Step 4: Code review and quality assessment.\n\n**🚨 TWO TYPES OF REVISIONS: FIX AND DELETE 🚨**\n\nAI performs a thorough review of the draft implementation for:\n\n**1. FIX - Improve existing code:**\n\n**Compilation & Syntax:**\n\n- TypeScript compilation errors and type mismatches\n- Syntax errors and missing semicolons/brackets\n- Correct function signatures and parameter types\n\n**Framework Compliance:**\n\n-",
+                                    type: "string"
+                                },
+                                final: {
+                                    description: "Step 5: Final production-ready test code.\n\nAI produces the final, polished version of the test code incorporating\nall review feedback. This code represents the completed test\nimplementation, ready for production deployment. When the draft code is\nalready perfect with no issues found during review, this value can be\nnull, indicating no revisions were necessary.\n\n**🚨 CRITICAL: APPLY ALL FIXES AND DELETIONS FROM REVIEW 🚨**\n\n- FIX all correctable issues identified in review\n- DELETE all prohibited code identified in review\n- If review found type error tests, they MUST be deleted in final\n- If review found code to DELETE, final MUST be different from draft\n- If review finds NO issues requiring changes, set to null\n\nAll identified issues must be resolved, and the code must meet the\nhighest quality standards. A null value indicates the draft code already\nmeets all requirements without modification.\n\nWorkflow: Review feedback → Apply FIXES → Apply DELETIONS →\nProduction-ready implementation (or null if no changes needed)\n\nThis is the ultimate deliverable that will be used in the actual test\nsuite when provided, otherwise the draft is used as-is.",
+                                    oneOf: [ {
+                                        type: "null"
+                                    }, {
+                                        type: "string"
+                                    } ]
+                                }
                             },
-                            final: {
-                                type: "string",
-                                nullable: true,
-                                description: "Step 5: Final production-ready test code.\n\nAI produces the final, polished version of the test code incorporating\nall review feedback. This code represents the completed test\nimplementation, ready for production deployment. When the draft code is\nalready perfect with no issues found during review, this value can be\nnull, indicating no revisions were necessary.\n\n**🚨 CRITICAL: APPLY ALL FIXES AND DELETIONS FROM REVIEW 🚨**\n\n- FIX all correctable issues identified in review\n- DELETE all prohibited code identified in review\n- If review found type error tests, they MUST be deleted in final\n- If review found code to DELETE, final MUST be different from draft\n- If review finds NO issues requiring changes, set to null\n\nAll identified issues must be resolved, and the code must meet the\nhighest quality standards. A null value indicates the draft code already\nmeets all requirements without modification.\n\nWorkflow: Review feedback → Apply FIXES → Apply DELETIONS →\nProduction-ready implementation (or null if no changes needed)\n\nThis is the ultimate deliverable that will be used in the actual test\nsuite when provided, otherwise the draft is used as-is."
-                            }
-                        },
-                        required: [ "review", "final" ],
-                        description: "Steps 4-5: Code review and final refinement process.\n\nContains the iterative improvement workflow that transforms the initial\ndraft into production-ready test code. The review phase identifies issues\nto fix or code to delete, followed by the final phase that produces the\npolished, production-ready test implementation.\n\nWorkflow: Draft → Review analysis → Final implementation\n\n------------------------------\n\nCurrent Type: {@link IAutoBeTestWriteApplication.IReviseProps}",
-                        additionalProperties: false
+                            required: [ "review", "final" ]
+                        }
                     }
                 },
-                required: [ "scenario", "domain", "draft", "revise" ],
-                description: " Complete specification for test generation including scenario,\ndomain, and implementation steps\n\n------------------------------\n\nCurrent Type: {@link IAutoBeTestWriteApplication.IProps}",
-                additionalProperties: false
-            },
-            description: "Main entry point for AI Function Call - generates complete E2E test code.\n\nThe AI executes this function to perform the entire test generation\nworkflow: scenario analysis → draft implementation → code review → final\ncode production. This structured approach ensures high-quality,\ncompilation-error-free test code.",
-            validate: (() => {
-                const _io0 = input => "string" === typeof input.scenario && "string" === typeof input.domain && "string" === typeof input.draft && ("object" === typeof input.revise && null !== input.revise && _io1(input.revise));
-                const _io1 = input => "string" === typeof input.review && (null === input.final || "string" === typeof input.final);
-                const _vo0 = (input, _path, _exceptionable = true) => [ "string" === typeof input.scenario || _report(_exceptionable, {
-                    path: _path + ".scenario",
-                    expected: "string",
-                    value: input.scenario
-                }), "string" === typeof input.domain || _report(_exceptionable, {
-                    path: _path + ".domain",
-                    expected: "string",
-                    value: input.domain
-                }), "string" === typeof input.draft || _report(_exceptionable, {
-                    path: _path + ".draft",
-                    expected: "string",
-                    value: input.draft
-                }), ("object" === typeof input.revise && null !== input.revise || _report(_exceptionable, {
-                    path: _path + ".revise",
-                    expected: "IAutoBeTestWriteApplication.IReviseProps",
-                    value: input.revise
-                })) && _vo1(input.revise, _path + ".revise", _exceptionable) || _report(_exceptionable, {
-                    path: _path + ".revise",
-                    expected: "IAutoBeTestWriteApplication.IReviseProps",
-                    value: input.revise
-                }) ].every(flag => flag);
-                const _vo1 = (input, _path, _exceptionable = true) => [ "string" === typeof input.review || _report(_exceptionable, {
-                    path: _path + ".review",
-                    expected: "string",
-                    value: input.review
-                }), null === input.final || "string" === typeof input.final || _report(_exceptionable, {
-                    path: _path + ".final",
-                    expected: "(null | string)",
-                    value: input.final
-                }) ].every(flag => flag);
-                const __is = input => "object" === typeof input && null !== input && _io0(input);
-                let errors;
-                let _report;
-                return input => {
-                    if (false === __is(input)) {
-                        errors = [];
-                        _report = __typia_transform__validateReport._validateReport(errors);
-                        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
-                            path: _path + "",
-                            expected: "IAutoBeTestWriteApplication.IProps",
-                            value: input
-                        })) && _vo0(input, _path + "", true) || _report(true, {
-                            path: _path + "",
-                            expected: "IAutoBeTestWriteApplication.IProps",
-                            value: input
-                        }))(input, "$input", true);
-                        const success = 0 === errors.length;
-                        return success ? {
-                            success,
-                            data: input
-                        } : {
-                            success,
-                            errors,
+                description: "Main entry point for AI Function Call - generates complete E2E test code.\n\nThe AI executes this function to perform the entire test generation\nworkflow: scenario analysis → draft implementation → code review → final\ncode production. This structured approach ensures high-quality,\ncompilation-error-free test code.",
+                validate: (() => {
+                    const _io0 = input => "string" === typeof input.scenario && "string" === typeof input.domain && "string" === typeof input.draft && ("object" === typeof input.revise && null !== input.revise && _io1(input.revise));
+                    const _io1 = input => "string" === typeof input.review && (null === input.final || "string" === typeof input.final);
+                    const _vo0 = (input, _path, _exceptionable = true) => [ "string" === typeof input.scenario || _report(_exceptionable, {
+                        path: _path + ".scenario",
+                        expected: "string",
+                        value: input.scenario
+                    }), "string" === typeof input.domain || _report(_exceptionable, {
+                        path: _path + ".domain",
+                        expected: "string",
+                        value: input.domain
+                    }), "string" === typeof input.draft || _report(_exceptionable, {
+                        path: _path + ".draft",
+                        expected: "string",
+                        value: input.draft
+                    }), ("object" === typeof input.revise && null !== input.revise || _report(_exceptionable, {
+                        path: _path + ".revise",
+                        expected: "IAutoBeTestWriteApplication.IReviseProps",
+                        value: input.revise
+                    })) && _vo1(input.revise, _path + ".revise", _exceptionable) || _report(_exceptionable, {
+                        path: _path + ".revise",
+                        expected: "IAutoBeTestWriteApplication.IReviseProps",
+                        value: input.revise
+                    }) ].every(flag => flag);
+                    const _vo1 = (input, _path, _exceptionable = true) => [ "string" === typeof input.review || _report(_exceptionable, {
+                        path: _path + ".review",
+                        expected: "string",
+                        value: input.review
+                    }), null === input.final || "string" === typeof input.final || _report(_exceptionable, {
+                        path: _path + ".final",
+                        expected: "(null | string)",
+                        value: input.final
+                    }) ].every(flag => flag);
+                    const __is = input => "object" === typeof input && null !== input && _io0(input);
+                    let errors;
+                    let _report;
+                    return input => {
+                        if (false === __is(input)) {
+                            errors = [];
+                            _report = __typia_transform__validateReport._validateReport(errors);
+                            ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
+                                path: _path + "",
+                                expected: "IAutoBeTestWriteApplication.IProps",
+                                value: input
+                            })) && _vo0(input, _path + "", true) || _report(true, {
+                                path: _path + "",
+                                expected: "IAutoBeTestWriteApplication.IProps",
+                                value: input
+                            }))(input, "$input", true);
+                            const success = 0 === errors.length;
+                            return success ? {
+                                success,
+                                data: input
+                            } : {
+                                success,
+                                errors,
+                                data: input
+                            };
+                        }
+                        return {
+                            success: true,
                             data: input
                         };
-                    }
-                    return {
-                        success: true,
-                        data: input
                     };
-                };
-            })()
-        } ]
-    }
+                })()
+            } ]
+        };
+        __typia_transform__llmApplicationFinalize._llmApplicationFinalize(application, {
+            ...{
+                validate: {
+                    write: validate
+                }
+            },
+            equals: false
+        });
+        return application;
+    })()
 };
 
 const orchestrateTest = ctx => async props => {
@@ -33361,6 +33882,57 @@ var TimedConversation;
     };
 })(TimedConversation || (TimedConversation = {}));
 
+const supportMistral = (agent, vendor) => {
+    if (vendor.model.includes("mistral") || vendor.model.includes("devstral") || vendor.model.includes("codestral")) {
+        agent.on("request", async e => {
+            const newMessages = [];
+            for (const m of e.body.messages) {
+                newMessages.push(m);
+                if (m.role === "tool") {
+                    m.tool_call_id = uuidToShortId(m.tool_call_id);
+                    newMessages.push({
+                        role: "assistant",
+                        content: "A tool has been called."
+                    });
+                } else if (m.role === "assistant") {
+                    for (const call of m.tool_calls ?? []) call.id = uuidToShortId(call.id);
+                }
+            }
+            e.body.messages = newMessages;
+        });
+    }
+};
+
+const BASE62_CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+
+function simpleHash(str) {
+    let h1 = 3735928559;
+    let h2 = 1103547991;
+    for (let i = 0; i < str.length; i++) {
+        const ch = str.charCodeAt(i);
+        h1 = Math.imul(h1 ^ ch, 2654435761);
+        h2 = Math.imul(h2 ^ ch, 1597334677);
+    }
+    h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507) ^ Math.imul(h2 ^ h2 >>> 13, 3266489909);
+    h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507) ^ Math.imul(h1 ^ h1 >>> 13, 3266489909);
+    return 4294967296 * (2097151 & h2) + (h1 >>> 0);
+}
+
+function toBase62(num, length) {
+    let result = "";
+    let n = num;
+    while (n > 0 && result.length < length) {
+        result = BASE62_CHARS[n % 62] + result;
+        n = Math.floor(n / 62);
+    }
+    return result.padStart(length, "0");
+}
+
+function uuidToShortId(uuid) {
+    const hash = simpleHash(uuid);
+    return toBase62(hash, 9);
+}
+
 const consentFunctionCall = async props => {
     const pointer = {
         value: null
@@ -33485,6 +34057,7 @@ const consentFunctionCall = async props => {
             };
         })() ]
     });
+    supportMistral(agent, props.vendor);
     const histories = await agent.conversate("Analyze and judge this assistant message please.");
     if (pointer.value === null) {
         const last = histories[histories.length - 1];
@@ -33594,6 +34167,7 @@ const createAutoBeContext = props => {
                     histories: next.histories,
                     controllers: [ next.controller ]
                 });
+                supportMistral(agent, props.vendor);
                 agent.on("request", async event => {
                     if (next.enforceFunctionCall === true && event.body.tools) event.body.tool_choice = "required";
                     if (event.body.parallel_tool_calls !== undefined) delete event.body.parallel_tool_calls;
@@ -33964,6 +34538,7 @@ class AutoBeAgent extends AutoBeAgentBase {
                 context: this.context_
             }) ]
         });
+        supportMistral(this.agentica_, props.vendor);
         this.agentica_.getHistories().push(...this.histories_.map(history => createAgenticaHistory({
             operations: this.agentica_.getOperations(),
             history
@@ -34201,7 +34776,7 @@ const sleepMap = {
     interfaceSchemasReview: 400,
     interfaceComplement: 2e3,
     interfaceComplete: 1e3,
-    interfacePrerequisites: 1e3,
+    interfacePrerequisites: 400,
     testStart: 1e3,
     testScenarios: 40,
     testScenariosReview: 40,