@autobe/agent 0.17.1 → 0.19.1

package/src/orchestrate/realize/{orchestrateRealizePlanner.ts → orchestrateRealizeScenario.ts}

@@ -2,8 +2,9 @@ import { AutoBeOpenApi, AutoBeRealizeAuthorization } from "@autobe/interface";
 import { ILlmSchema } from "@samchon/openapi";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
+import { IAutoBeRealizeScenarioApplication } from "./structures/IAutoBeRealizeScenarioApplication";
 
-export interface RealizePlannerOutput {
+export interface IAutoBeRealizeScenario {
   /**
    * The name of the function to be generated.
    *
@@ -56,7 +57,7 @@ export interface RealizePlannerOutput {
    * Extracted from the Swagger operation method. Used to define the request
    * type during code and test generation.
    */
-  operationType: "get" | "post" | "put" | "delete" | "patch";
+  method: "get" | "post" | "put" | "delete" | "patch";
 
   /**
    * List of scenario descriptions for test code generation.
@@ -91,16 +92,17 @@ export interface RealizePlannerOutput {
  * next step in the AutoBE pipeline, which is responsible for generating the
  * actual implementation code.
  *
+ * @author Kakasoo
  * @param ctx - AutoBE context including model and configuration
  * @param operation - A single OpenAPI operation object to analyze and plan
  * @returns A planning object containing all structural information needed to
  *   generate the function
  */
-export const orchestrateRealizePlanner = async <Model extends ILlmSchema.Model>(
+export const orchestrateRealizeScenario = <Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   operation: AutoBeOpenApi.IOperation,
   authorization?: AutoBeRealizeAuthorization,
-): Promise<RealizePlannerOutput> => {
+): IAutoBeRealizeScenarioApplication.IProps => {
   const testScenarios =
     ctx
       .state()
@@ -110,18 +112,16 @@ export const orchestrateRealizePlanner = async <Model extends ILlmSchema.Model>(
           el.scenario.endpoint.path === operation.path,
       ) ?? [];
 
+  const functionName = `${operation.method}_${operation.path
+    .replaceAll("/", "_")
+    .replaceAll("-", "_")
+    .replaceAll("{", "$")
+    .replaceAll("}", "")}`;
   return {
-    description: operation.description,
-    parameters: operation.parameters,
-    inputSchema: operation.requestBody,
-    outputSchema: operation.responseBody,
-    operationType: operation.method,
+    operation: operation,
+    functionName: functionName,
+    location: `src/providers/${functionName}.ts`,
     testScenarios: testScenarios.map((el) => el.scenario.draft),
-    functionName: `${operation.method}_${operation.path
-      .replaceAll("/", "_")
-      .replaceAll("-", "_")
-      .replaceAll("{", "$")
-      .replaceAll("}", "")}`,
     decoratorEvent: authorization,
-  } satisfies RealizePlannerOutput;
+  };
 };

package/src/orchestrate/realize/orchestrateRealizeWrite.ts

@@ -0,0 +1,128 @@
+import {
+  AutoBeRealizeAuthorization,
+  AutoBeRealizeWriteEvent,
+} from "@autobe/interface";
+import { ILlmApplication, ILlmController, ILlmSchema } from "@samchon/openapi";
+import { IPointer } from "tstl";
+import typia from "typia";
+
+import { AutoBeContext } from "../../context/AutoBeContext";
+import { assertSchemaModel } from "../../context/assertSchemaModel";
+import { getTestScenarioArtifacts } from "../test/compile/getTestScenarioArtifacts";
+import { IAutoBeTestScenarioArtifacts } from "../test/structures/IAutoBeTestScenarioArtifacts";
+import { transformRealizeWriteHistories } from "./histories/transformRealizeWriteHistories";
+import { IAutoBeRealizeScenarioApplication } from "./structures/IAutoBeRealizeScenarioApplication";
+import { IAutoBeRealizeWriteApplication } from "./structures/IAutoBeRealizeWriteApplication";
+import { replaceImportStatements } from "./utils/replaceImportStatements";
+
+export async function orchestrateRealizeWrite<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  props: {
+    totalAuthorizations: AutoBeRealizeAuthorization[];
+    authorization: AutoBeRealizeAuthorization | null;
+    scenario: IAutoBeRealizeScenarioApplication.IProps;
+    progress: IProgress;
+  },
+): Promise<AutoBeRealizeWriteEvent> {
+  const artifacts: IAutoBeTestScenarioArtifacts =
+    await getTestScenarioArtifacts(ctx, {
+      endpoint: props.scenario.operation,
+      dependencies: [],
+    });
+  const pointer: IPointer<IAutoBeRealizeWriteApplication.IProps | null> = {
+    value: null,
+  };
+  const { tokenUsage } = await ctx.conversate({
+    source: "realizeWrite",
+    histories: transformRealizeWriteHistories({
+      state: ctx.state(),
+      scenario: props.scenario,
+      artifacts,
+      authorization: props.authorization,
+      totalAuthorizations: props.totalAuthorizations,
+    }),
+    controller: createController({
+      model: ctx.model,
+      build: (next) => {
+        pointer.value = next;
+      },
+    }),
+    enforceFunctionCall: true,
+    message: [
+      `Write complete, production-ready TypeScript code that strictly follows these rules:`,
+      "",
+      `DO NOT:`,
+      `- Use the native \`Date\` type anywhere`,
+      `- Use \`as\` for type assertions`,
+      ``,
+      `DO:`,
+      `- Write all date/datetime values as \`string & tags.Format<'date-time'>\``,
+      `- Generate UUIDs using \`v4()\` and type as \`string & tags.Format<'uuid'>\``,
+      `- Resolve types properly without assertions`,
+      `- Type all functions with clear parameter and return types`,
+      `6. Do not skip validations or default values where necessary.`,
+      `7. Follow functional, immutable, and consistent code structure.`,
+      "",
+      `Use \`@nestia/e2e\` test structure if relevant.`,
+    ].join("\n"),
+  });
+  if (pointer.value === null) throw new Error("Failed to write code.");
+
+  pointer.value.implementationCode = await replaceImportStatements(ctx)(
+    artifacts,
+    pointer.value.implementationCode,
+    props.authorization?.payload.name,
+  );
+
+  const event: AutoBeRealizeWriteEvent = {
+    type: "realizeWrite",
+    location: props.scenario.location,
+    content: pointer.value.implementationCode,
+    tokenUsage,
+    completed: ++props.progress.completed,
+    total: props.progress.total,
+    step: ctx.state().analyze?.step ?? 0,
+    created_at: new Date().toISOString(),
+  };
+  ctx.dispatch(event);
+  return event;
+}
+
+function createController<Model extends ILlmSchema.Model>(props: {
+  model: Model;
+  build: (next: IAutoBeRealizeWriteApplication.IProps) => void;
+}): ILlmController<Model> {
+  assertSchemaModel(props.model);
+
+  const application: ILlmApplication<Model> = collection[
+    props.model
+  ] satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
+
+  return {
+    protocol: "class",
+    name: "Write code",
+    application,
+    execute: {
+      coding: (next) => {
+        props.build(next);
+      },
+    } satisfies IAutoBeRealizeWriteApplication,
+  };
+}
+
+const claude = typia.llm.application<
+  IAutoBeRealizeWriteApplication,
+  "claude"
+>();
+const collection = {
+  chatgpt: typia.llm.application<IAutoBeRealizeWriteApplication, "chatgpt">(),
+  claude,
+  llama: claude,
+  deepseek: claude,
+  "3.1": claude,
+};
+
+export interface IProgress {
+  total: number;
+  completed: number;
+}

package/src/orchestrate/realize/structures/IAutoBeRealizeAuthorizationApplication.ts

@@ -1,3 +1,5 @@
+import { CamelPattern, PascalPattern } from "@autobe/interface";
+
 export interface IAutoBeRealizeAuthorizationApplication {
   createDecorator: (
     next: IAutoBeRealizeAuthorizationApplication.IProps,
@@ -38,8 +40,10 @@ export namespace IAutoBeRealizeAuthorizationApplication {
      * format (e.g., adminAuthorize, userAuthorize). This function will be
      * called by the decorator to verify JWT tokens and return authenticated
      * user information for the specified role.
+     *
+     * DO: Use camelCase naming convention.
      */
-    name: string;
+    name: string & CamelPattern;
 
     /**
      * Complete TypeScript code for the authentication Provider function. Must
@@ -59,8 +63,10 @@ export namespace IAutoBeRealizeAuthorizationApplication {
      * decorator in Controller methods to automatically authenticate and
      * authorize users for the specific role, injecting the authenticated user
      * payload as a method parameter.
+     *
+     * DO: Use PascalCase naming convention.
      */
-    name: string;
+    name: string & PascalPattern;
 
     /**
      * Complete TypeScript code for the authentication Decorator implementation.
@@ -79,8 +85,10 @@ export namespace IAutoBeRealizeAuthorizationApplication {
      * (e.g., AdminPayload, UserPayload). This type defines the structure of the
      * authenticated user data that will be injected into Controller methods
      * when using the decorator.
+     *
+     * DO: Use PascalCase naming convention.
      */
-    name: string;
+    name: string & PascalPattern;
 
     /**
      * Complete TypeScript code for the Payload type interface in {Role}Payload

package/src/orchestrate/realize/structures/IAutoBeRealizeCorrectApplication.ts

@@ -0,0 +1,81 @@
+import { IAutoBeRealizeWriteApplication } from "./IAutoBeRealizeWriteApplication";
+
+export interface IAutoBeRealizeCorrectApplication {
+  review: (props: IAutoBeRealizeCorrectApplication.IProps) => void;
+}
+
+export namespace IAutoBeRealizeCorrectApplication {
+  export interface IProps extends IAutoBeRealizeWriteApplication.IProps {
+    /**
+     * Compilation Error Analysis and Resolution Strategy
+     *
+     * This field contains a detailed analysis of TypeScript compilation errors
+     * that occurred during the previous compilation attempt, along with
+     * specific strategies to resolve each error.
+     *
+     * The analysis MUST include:
+     *
+     * 📊 ERROR BREAKDOWN:
+     *
+     * - List of all TypeScript error codes encountered (e.g., TS2339, TS2345)
+     * - Exact error messages and the lines/files where they occurred
+     * - Categorization of errors by type (type mismatch, missing property, etc.)
+     *
+     * 🔍 ROOT CAUSE ANALYSIS:
+     *
+     * - Why each error occurred (e.g., incorrect type assumptions, missing
+     *   fields)
+     * - Relationship between errors (e.g., cascading errors from a single issue)
+     * - Common patterns identified across multiple errors
+     *
+     * 🛠 RESOLUTION STRATEGY:
+     *
+     * - Specific fixes for each error type
+     * - Priority order for addressing errors (fix critical errors first)
+     * - Alternative approaches if the direct fix is not possible
+     *
+     * 📝 SCHEMA VERIFICATION:
+     *
+     * - Re-verification of Prisma schema fields actually available
+     * - Identification of assumed fields that don't exist
+     * - Correct field types and relationships
+     *
+     * ⚠️ COMMON ERROR PATTERNS TO CHECK:
+     *
+     * - Using non-existent fields (e.g., deleted_at, created_by)
+     * - Type mismatches in Prisma operations
+     * - Incorrect date handling (using Date instead of string)
+     * - Missing required fields in create/update operations
+     * - Incorrect relation handling in nested operations
+     *
+     * 🎯 CORRECTION APPROACH:
+     *
+     * - Remove references to non-existent fields
+     * - Fix type conversions (especially dates with toISOStringSafe())
+     * - Simplify complex nested operations into separate queries
+     * - Add missing required fields
+     * - Use correct Prisma input types
+     *
+     * Example structure:
+     *
+     *     Errors Found:
+     *     1. TS2339: Property 'deleted_at' does not exist on type 'User'
+     *        - Cause: Field assumed but not in schema
+     *        - Fix: Remove all deleted_at references
+     *
+     *     2. TS2345: Type 'Date' is not assignable to type 'string'
+     *        - Cause: Direct Date assignment without conversion
+     *        - Fix: Use toISOStringSafe() for all date values
+     *
+     *     Resolution Plan:
+     *     1. First, remove all non-existent field references
+     *     2. Then, fix all date type conversions
+     *     3. Finally, adjust Prisma query structures
+     *
+     * This analysis ensures the review process addresses all compilation errors
+     * systematically and produces error-free code in the corrected
+     * implementation.
+     */
+    errorAnalysis: string;
+  }
+}

package/src/orchestrate/realize/structures/IAutoBeRealizeScenarioApplication.ts

@@ -0,0 +1,43 @@
+import { AutoBeOpenApi, AutoBeRealizeAuthorization } from "@autobe/interface";
+
+export namespace IAutoBeRealizeScenarioApplication {
+  export interface IProps {
+    /** The OpenAPI operation to be realized. */
+    operation: AutoBeOpenApi.IOperation;
+
+    /**
+     * The name of the function to be generated.
+     *
+     * Derived from the Swagger path and method. The function name must be
+     * written in snake_case. It serves as the entry point in both code
+     * generation and test code.
+     *
+     * Once the function is generated, the function name and file name will be
+     * the same. The generated file will be located at
+     * `src/providers/${function_name}.ts`.
+     */
+    functionName: string;
+
+    /** For example, `src/providers/${function_name}.ts`. */
+    location: string;
+
+    /**
+     * List of scenario descriptions for test code generation.
+     *
+     * Each scenario describes the expected behavior of the function under
+     * certain conditions. Used as a basis for TDD-style automated test
+     * generation.
+     */
+    testScenarios: string[];
+
+    /**
+     * Optional decorator event for customizing code generation behavior.
+     *
+     * Provides additional metadata or instructions that can modify how the
+     * function implementation is generated. Can include custom annotations,
+     * middleware configurations, or special handling directives that affect the
+     * final code output.
+     */
+    decoratorEvent?: AutoBeRealizeAuthorization;
+  }
+}

package/src/orchestrate/realize/structures/{IAutoBeRealizeCoderApplication.ts → IAutoBeRealizeWriteApplication.ts}

@@ -1,79 +1,9 @@
-import { AutoBeOpenApi } from "@autobe/interface";
-
-import { FAILED } from "./IAutoBeRealizeFailedSymbol";
-
-export interface IAutoBeRealizeCoderApplication {
-  programming: (input: IAutoBeRealizeCoderApplication.IProps) => void;
+export interface IAutoBeRealizeWriteApplication {
+  coding: (next: IAutoBeRealizeWriteApplication.IProps) => void;
 }
 
-export namespace IAutoBeRealizeCoderApplication {
-  /**
-   * Properties for the component or function that consumes the output of the
-   * code generation pipeline.
-   */
+export namespace IAutoBeRealizeWriteApplication {
   export interface IProps {
-    /**
-     * The detailed output of the code generation process, containing all phases
-     * from planning to final implementation of a TypeScript provider function.
-     */
-    output: Omit<IAutoBeRealizeCoderApplication.RealizeCoderOutput, "filename">;
-  }
-
-  /**
-   * Represents the complete output of a code generation pipeline. Each field
-   * corresponds to a stage in the Chain of Thought (CoT) process for generating
-   * a production-quality TypeScript function.
-   *
-   * All fields contain TypeScript code strings and follow these rules:
-   *
-   * - All code must be valid TypeScript or structurally valid even if incomplete.
-   * - Each phase builds upon the previous one and must resolve specific concerns.
-   * - All phases must follow system conventions around structure, typing, and
-   *   logic.
-   */
-  export interface RealizeCoderOutput {
-    /** @ignore */
-    filename: string;
-
-    /**
-     * Error Analysis Phase (Optional)
-     *
-     * 🔍 Analyzes TypeScript compilation errors from previous attempts.
-     *
-     * This field should contain a detailed analysis of any TypeScript errors
-     * encountered, with root cause identification and resolution strategies:
-     *
-     * Common Error Patterns to Analyze:
-     *
-     * 1. **"Property does not exist" (TS2353)**:
-     *
-     *    - Root Cause: Using fields that don't exist in Prisma schema
-     *    - Example: Using `deleted_at` when the field doesn't exist in the model
-     *    - Resolution: Remove the non-existent field or use hard delete instead
-     * 2. **"Type 'void' is not assignable" (TS2322)**:
-     *
-     *    - Root Cause: Using `typia.assertGuard` instead of `typia.assert`
-     *    - `assertGuard` returns void, `assert` returns the validated value
-     *    - Resolution: Change `typia.assertGuard<T>()` to `typia.assert<T>()`
-     * 3. **"Type 'Date' is not assignable to type 'string &
-     *    Format<'date-time'>'"**:
-     *
-     *    - Root Cause: Assigning native Date objects to string fields
-     *    - Resolution: Use `toISOStringSafe(dateValue)` for all date conversions
-     * 4. **Complex Prisma Type Errors**:
-     *
-     *    - Root Cause: Nested operations with incompatible types
-     *    - Resolution: Use separate queries and application-level joins
-     *
-     * Analysis Format:
-     *
-     * - List each error with its TypeScript error code
-     * - Identify the root cause (schema mismatch, wrong function usage, etc.)
-     * - Provide specific resolution steps
-     * - Note any schema limitations discovered
-     */
-    errorAnalysis?: string;
-
     /**
      * Step 1.
      *
@@ -83,16 +13,18 @@ export namespace IAutoBeRealizeCoderApplication {
      * function according to the Realize Coder Agent specification. Before
      * writing the actual code, think through the logic and structure.
      *
-     * The plan MUST follow MANDATORY SCHEMA-FIRST APPROACH:
+     * The plan follows a SCHEMA-FIRST APPROACH:
      *
-     * 📋 STEP 1 - PRISMA SCHEMA VERIFICATION (MOST CRITICAL):
+     * 📋 STEP 1 - PRISMA SCHEMA VERIFICATION:
      *
-     * - EXAMINE the actual Prisma schema model definition
-     * - LIST EVERY field that exists in the model with exact types
-     * - EXPLICITLY NOTE fields that DO NOT exist (e.g., "Note: deleted_at field
-     *   DOES NOT EXIST")
-     * - Common assumption errors to avoid: `deleted_at`, `created_by`,
-     *   `updated_by`, `is_deleted`, `is_active`
+     * DO:
+     * - Examine the actual Prisma schema model definition
+     * - List EVERY field that exists in the model with exact types
+     * - Explicitly note fields that DO NOT exist
+     * 
+     * DO NOT:
+     * - Assume common fields exist without verification
+     * - Use fields like deleted_at, created_by, updated_by, is_deleted, is_active without checking
      *
      * 📋 STEP 2 - FIELD INVENTORY:
      *
@@ -228,8 +160,9 @@ export namespace IAutoBeRealizeCoderApplication {
      * Draft WITHOUT using native Date type.
      *
      * This is the initial drafting phase where you outline the basic skeleton
-     * of the function. CRITICAL: This draft must NEVER use the native Date
-     * type.
+     * of the function.
+     * 
+     * DO NOT: Use the native Date type.
      *
      * - The function signature must correctly include `user`, `parameters`, and
      *   `body` arguments.
@@ -238,13 +171,13 @@ export namespace IAutoBeRealizeCoderApplication {
      * - Mark any incomplete or missing parts clearly with placeholders (e.g.,
      *   comments or temporary values).
      *
-     * ⚠️ Import rules:
+     * Import rules:
      *
-     * - Do NOT add any new import statements manually.
-     * - All necessary imports are provided globally or by the system
-     *   automatically.
-     * - Writing import statements directly is prohibited and may cause compile
-     *   errors. If import errors occur, check your environment configuration.
+     * DO NOT:
+     * - Add any new import statements manually
+     * - Write import statements directly (this causes compile errors)
+     * 
+     * Note: All necessary imports are provided globally or by the system automatically.
      *
      * ✅ Requirements:
      *
@@ -349,10 +282,4 @@ export namespace IAutoBeRealizeCoderApplication {
      */
     implementationCode: string;
   }
-
-  export interface IPipeOutput {
-    result: RealizeCoderOutput | FAILED;
-
-    operation: AutoBeOpenApi.IOperation;
-  }
 }

package/src/orchestrate/realize/utils/replaceImportStatements.ts

@@ -46,6 +46,12 @@ export function replaceImportStatements<Model extends ILlmSchema.Model>(
       .replace(
         /import\s*{\s*toISOStringSafe\s*}\s*from\s*["']\.\.\/util\/toISOStringSafe["']\s*;?\s*/gm,
         "",
+      )
+      // Remove JWT import if it exists (to prevent duplication)
+      .replace(/import\s+jwt\s+from\s*["']jsonwebtoken["']\s*;?\s*/gm, "")
+      .replace(
+        /import\s*\*\s*as\s+jwt\s+from\s*["']jsonwebtoken["']\s*;?\s*/gm,
+        "",
       );
 
     // Remove any existing API structure imports
@@ -59,7 +65,7 @@ export function replaceImportStatements<Model extends ILlmSchema.Model>(
       /import\s*(?:type\s*)?{\s*[^}]+\s*}\s*from\s*["']@ORGANIZATION\/PROJECT-api\/lib\/structures\/[^"']+["']\s*;?\s*/gm,
       "",
     );
-    
+
     // Remove specific type imports that match our typeReferences
     for (const ref of typeReferences) {
       // Remove any import of this specific type from any path
@@ -81,6 +87,7 @@ export function replaceImportStatements<Model extends ILlmSchema.Model>(
 
     // Build the standard imports
     const imports = [
+      'import jwt from "jsonwebtoken";',
       'import { MyGlobal } from "../MyGlobal";',
       'import typia, { tags } from "typia";',
       'import { Prisma } from "@prisma/client";',
@@ -119,6 +126,8 @@ export function replaceImportStatements<Model extends ILlmSchema.Model>(
     // Apply final beautification
     code = await compiler.typescript.beautify(code);
 
+    code = code.replaceAll("typia.tags.assert", "typia.assert");
+
     return code;
   };
 }

package/src/orchestrate/test/experimental/orchestrateTestCorrect.ast

@@ -89,7 +89,7 @@ async function correct<Model extends ILlmSchema.Model>(
     },
     histories: transformTestCorrectHistories(written, event.result),
     controllers: [
-      createApplication({
+      createController({
         model: ctx.model,
         build: (next) => {
           pointer.value = next;
@@ -153,7 +153,7 @@ function getUnionTypeName(unit: IJsonSchemaUnit): string {
     .join(" | ");
 }
 
-function createApplication<Model extends ILlmSchema.Model>(props: {
+function createController<Model extends ILlmSchema.Model>(props: {
   model: Model;
   build: (next: ICorrectTestFunctionProps) => void;
 }): IAgenticaController.IClass<Model> {
@@ -161,7 +161,7 @@ function createApplication<Model extends ILlmSchema.Model>(props: {
 
   const application: ILlmApplication<Model> = collection[
     props.model
-  ] as unknown as ILlmApplication<Model>;
+  ] satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
   return {
     protocol: "class",
     name: "Modify Test Code",
@@ -176,16 +176,12 @@ function createApplication<Model extends ILlmSchema.Model>(props: {
 
 const claude = typia.llm.application<
   IApplication,
-  "claude",
-  {
-    reference: true;
-  }
+  "claude"
 >();
 const collection = {
   chatgpt: typia.llm.application<
     IApplication,
-    "chatgpt",
-    { reference: true }
+    "chatgpt"
   >(),
   claude,
   llama: claude,

package/src/orchestrate/test/experimental/orchestrateTestWrite.ast

@@ -145,7 +145,7 @@ async function process<Model extends ILlmSchema.Model>(
       failure,
     }),
     controllers: [
-      createApplication({
+      createController({
         model: ctx.model,
         document: ctx.state().interface!.document,
         build: (next) => {
@@ -203,7 +203,7 @@ function getUnionTypeName(unit: IJsonSchemaUnit): string {
     .join(" | ");
 }
 
-function createApplication<Model extends ILlmSchema.Model>(props: {
+function createController<Model extends ILlmSchema.Model>(props: {
   model: Model;
   document: AutoBeOpenApi.IDocument;
   build: (next: ICreateTestCodeProps) => void;
@@ -225,12 +225,8 @@ function createApplication<Model extends ILlmSchema.Model>(props: {
       AutoBeEndpointComparator.hashCode,
       AutoBeEndpointComparator.equals,
     );
-  const application: ILlmApplication<Model> = collection[
-    props.model
-  ] as unknown as ILlmApplication<Model>;
-  application.functions[0].validate = (
-    input: unknown,
-  ): IValidation<unknown> => {
+
+  const validate = (input: unknown): IValidation<ICreateTestCodeProps> => {
     const result: IValidation<ICreateTestCodeProps> =
       typia.validate<ICreateTestCodeProps>(input);
     if (result.success === false) return result;
@@ -250,6 +246,11 @@ function createApplication<Model extends ILlmSchema.Model>(props: {
           errors: context.errors,
         };
   };
+  const application: ILlmApplication<Model> = collection[
+    props.model === "chatgpt" ? "chatgpt" : "claude"
+  ](
+    validate,
+  ) satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
 
   return {
     protocol: "class",
@@ -263,23 +264,23 @@ function createApplication<Model extends ILlmSchema.Model>(props: {
   };
 }
 
-const claude = typia.llm.application<
-  IApplication,
-  "claude",
-  { reference: true }
->();
 const collection = {
-  chatgpt: typia.llm.application<
-    IApplication,
-    "chatgpt",
-    { reference: true }
-  >(),
-  claude,
-  llama: claude,
-  deepseek: claude,
-  "3.1": claude,
+  chatgpt: (validate: Validator) =>
+    typia.llm.application<IApplication, "chatgpt">({
+      validate: {
+        createTestCode: validate,
+      },
+    }),
+  claude: (validate: Validator) =>
+    typia.llm.application<IApplication, "claude">({
+      validate: {
+        createTestCode: validate,
+      },
+    }),
 };
 
+type Validator = (input: unknown) => IValidation<ICreateTestCodeProps>;
+
 interface IApplication {
   createTestCode(props: ICreateTestCodeProps): void;
 }