@typia/interface 12.0.0-dev.20260306 → 12.0.0-dev.20260307

package/lib/http/IHttpLlmApplication.d.ts

@@ -18,7 +18,6 @@ import { IHttpMigrateRoute } from "./IHttpMigrateRoute";
  *
  * Configure behavior via {@link IHttpLlmApplication.IConfig}:
  *
- * - {@link IHttpLlmApplication.IConfig.separate}: Split LLM vs human parameters
  * - {@link IHttpLlmApplication.IConfig.maxLength}: Function name length limit
  * - {@link ILlmSchema.IConfig.strict}: OpenAI structured output mode
  *
@@ -35,15 +34,6 @@ export interface IHttpLlmApplication {
 export declare namespace IHttpLlmApplication {
     /** Configuration for HTTP LLM application composition. */
     interface IConfig extends ILlmSchema.IConfig {
-        /**
-         * Separates parameters into LLM and human parts.
-         *
-         * Use for file uploads or sensitive data that LLM cannot handle. Return
-         * `true` for human-composed, `false` for LLM-composed.
-         *
-         * @default null
-         */
-        separate: null | ((schema: ILlmSchema) => boolean);
         /**
          * Maximum function name length. Truncated or UUID if exceeded.
          *

package/lib/http/IHttpLlmFunction.d.ts

@@ -1,85 +1,29 @@
 import { OpenApi } from "../openapi/OpenApi";
-import { ILlmSchema } from "../schema/ILlmSchema";
-import { IValidation } from "../schema/IValidation";
+import { ILlmFunction } from "../schema/ILlmFunction";
 import { IHttpMigrateRoute } from "./IHttpMigrateRoute";
 /**
  * LLM function calling schema from OpenAPI operation.
  *
- * `IHttpLlmFunction` represents a single HTTP endpoint converted to LLM
- * function calling format. Generated from {@link OpenApi.IOperation} as part of
- * {@link IHttpLlmApplication}.
+ * Extends {@link ILlmFunction} with HTTP-specific properties. Generated from
+ * {@link OpenApi.IOperation} as part of {@link IHttpLlmApplication}.
  *
- * Key properties:
+ * - {@link method}, {@link path}: HTTP endpoint info
+ * - {@link operation}: Source OpenAPI operation
+ * - {@link route}: Source migration route
  *
- * - {@link name}: Function name (max 64 chars for OpenAI compatibility)
- * - {@link parameters}: Input schema with path/query/body merged
- * - {@link output}: Response schema (undefined if void)
- * - {@link description}: Critical for LLM function selection
- * - {@link validate}: Built-in argument validator for error feedback
- *
- * The {@link validate} function is essential: LLMs make frequent type errors
- * (e.g., `"123"` instead of `123`). Validate and retry improves success rate
- * from ~50% to 99%.
+ * Inherits {@link parse} and {@link validate} from {@link ILlmFunction}.
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export interface IHttpLlmFunction {
+export interface IHttpLlmFunction extends ILlmFunction {
     /** HTTP method of the endpoint. */
     method: "get" | "post" | "patch" | "put" | "delete";
     /** Path of the endpoint. */
     path: string;
-    /**
-     * Function name composed from {@link IHttpMigrateRoute.accessor}.
-     *
-     * @maxLength 64
-     */
-    name: string;
-    /**
-     * Parameter schema.
-     *
-     * With keyword mode: single object with pathParameters, query, body merged.
-     * Without keyword mode: array of [pathParameters..., query?, body?].
-     */
-    parameters: ILlmSchema.IParameters;
-    /**
-     * Separated parameters when {@link IHttpLlmApplication.IConfig.separate} is
-     * set.
-     */
-    separated?: IHttpLlmFunction.ISeparated;
-    /**
-     * Return type as an object parameters schema.
-     *
-     * Wraps the return type in an {@link ILlmSchema.IParameters} object with
-     * `$defs` for shared type definitions and `properties` for the structured
-     * output. `undefined` if the endpoint returns void.
-     */
-    output?: ILlmSchema.IParameters | undefined;
-    /** Function description for LLM context. Critical for function selection. */
-    description?: string | undefined;
-    /** Whether the function is deprecated. */
-    deprecated?: boolean | undefined;
     /** Category tags from {@link OpenApi.IOperation.tags}. */
     tags?: string[];
-    /**
-     * Validates LLM-composed arguments.
-     *
-     * LLMs frequently make type errors. Use this to provide validation feedback
-     * and retry. Success rate improves from ~50% to 99% on retry.
-     */
-    validate: (args: unknown) => IValidation<unknown>;
     /** Returns the source {@link OpenApi.IOperation}. */
     operation: () => OpenApi.IOperation;
     /** Returns the source {@link IHttpMigrateRoute}. */
     route: () => IHttpMigrateRoute;
 }
-export declare namespace IHttpLlmFunction {
-    /** Collection of separated parameters. */
-    interface ISeparated {
-        /** Parameters for LLM composition. Always at least empty object. */
-        llm: ILlmSchema.IParameters;
-        /** Parameters for human composition. */
-        human: ILlmSchema.IParameters | null;
-        /** Validates separated LLM arguments. */
-        validate?: ((args: unknown) => IValidation<unknown>) | undefined;
-    }
-}

package/lib/openapi/OpenApi.d.ts

@@ -35,7 +35,7 @@ export declare namespace OpenApi {
      *
      * Contains all API metadata, paths, operations, and reusable components. The
      * `x-samchon-emended-v4` marker indicates this document has been processed by
-     * `@samchon/openapi` to normalize schema formats.
+     * `samchon/typia` to normalize schema formats.
      */
     interface IDocument {
         /** OpenAPI version. */

package/lib/schema/IJsonParseResult.d.ts

@@ -0,0 +1,124 @@
+import { DeepPartial } from "../typings/DeepPartial";
+/**
+ * Result of lenient JSON parsing.
+ *
+ * `IJsonParseResult<T>` represents the result of parsing JSON that may be
+ * incomplete, malformed, or contain non-standard syntax (e.g., unquoted keys,
+ * trailing commas, missing quotes).
+ *
+ * Unlike standard JSON parsing which fails on any syntax error, lenient parsing
+ * attempts to recover as much data as possible while reporting issues.
+ *
+ * Check the {@link IJsonParseResult.success} discriminator:
+ *
+ * - `true` → {@link IJsonParseResult.ISuccess} with parsed
+ *   {@link IJsonParseResult.ISuccess.data}
+ * - `false` → {@link IJsonParseResult.IFailure} with partial
+ *   {@link IJsonParseResult.IFailure.data} and
+ *   {@link IJsonParseResult.IFailure.errors}
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @template T The expected type after successful parsing
+ */
+export type IJsonParseResult<T = unknown> = IJsonParseResult.ISuccess<T> | IJsonParseResult.IFailure<T>;
+export declare namespace IJsonParseResult {
+    /**
+     * Successful parsing result.
+     *
+     * Indicates the JSON was parsed without any errors. The data may still have
+     * been recovered from non-standard syntax (e.g., unquoted keys, trailing
+     * commas), but no information was lost.
+     *
+     * @template T The parsed type
+     */
+    interface ISuccess<T = unknown> {
+        /**
+         * Success discriminator.
+         *
+         * Always `true` for successful parsing.
+         */
+        success: true;
+        /** The parsed data with correct type. */
+        data: T;
+    }
+    /**
+     * Failed parsing result with partial data and errors.
+     *
+     * Indicates the JSON had syntax errors that could not be fully recovered. The
+     * {@link data} contains whatever could be parsed, and {@link errors} describes
+     * what went wrong.
+     *
+     * @template T The expected type (data may be partial)
+     */
+    interface IFailure<T = unknown> {
+        /**
+         * Success discriminator.
+         *
+         * Always `false` for failed parsing.
+         */
+        success: false;
+        /**
+         * Partially parsed data.
+         *
+         * Contains whatever could be recovered from the malformed JSON. May be
+         * incomplete or have missing properties.
+         */
+        data: DeepPartial<T>;
+        /**
+         * The original input string that was parsed.
+         *
+         * Preserved for debugging or error correction purposes.
+         */
+        input: string;
+        /**
+         * Array of parsing errors encountered.
+         *
+         * Each error describes a specific issue found during parsing, with location
+         * and suggested fix.
+         */
+        errors: IError[];
+    }
+    /**
+     * Detailed information about a parsing error.
+     */
+    interface IError {
+        /**
+         * Property path to the error location.
+         *
+         * A dot-notation path from the root to the error location. Uses `$input` as
+         * the root.
+         *
+         * @example
+         *   $input.user.email;
+         *
+         * @example
+         *   $input.items[0].price;
+         */
+        path: string;
+        /**
+         * What was expected at this location.
+         *
+         * @example
+         *   JSON value (string, number, boolean, null, object, or array)
+         *
+         * @example
+         *   quoted string
+         *
+         * @example
+         *   ":";
+         */
+        expected: string;
+        /**
+         * Description of what was actually found.
+         *
+         * Human/AI-readable message explaining the issue.
+         *
+         * @example
+         *   unquoted string 'abc' - did you forget quotes?
+         *
+         * @example
+         *   missing opening quote for 'hello'
+         */
+        value: unknown;
+    }
+}

package/lib/schema/IJsonParseResult.js

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

package/lib/schema/IJsonParseResult.js.map

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

package/lib/schema/ILlmApplication.d.ts

@@ -10,8 +10,6 @@ import { IValidation } from "./IValidation";
  *
  * Configure behavior via {@link ILlmApplication.IConfig}:
  *
- * - {@link ILlmApplication.IConfig.separate}: Split parameters into LLM-fillable
- *   vs human-required (e.g., file uploads, passwords)
  * - {@link ILlmApplication.IConfig.validate}: Custom validation per method
  * - {@link ILlmSchema.IConfig.strict}: OpenAI structured output mode
  * - {@link ILlmSchema.IConfig.reference}: Control `$ref` inlining behavior
@@ -52,23 +50,10 @@ export declare namespace ILlmApplication {
      * Configuration for LLM application generation.
      *
      * Extends {@link ILlmSchema.IConfig} with application-specific options for
-     * parameter separation and custom validation. These settings control how the
-     * application schema is generated from the source class.
+     * custom validation. These settings control how the application schema is
+     * generated from the source class.
      */
     interface IConfig<Class extends object = any> extends ILlmSchema.IConfig {
-        /**
-         * Function to separate LLM-fillable from human-required parameters.
-         *
-         * When provided, this function is called for each parameter schema to
-         * determine if it should be filled by the LLM (`false`) or require human
-         * input (`true`). Use this for sensitive data like passwords, file uploads,
-         * or data the LLM cannot generate.
-         *
-         * @default null (no separation)
-         * @param schema - The parameter schema to evaluate
-         * @returns `true` if human input required, `false` if LLM can fill
-         */
-        separate: null | ((schema: ILlmSchema) => boolean);
         /**
          * Custom validation functions per method name.
          *
@@ -92,4 +77,12 @@ export declare namespace ILlmApplication {
     type IValidationHook<Class extends object> = {
         [K in keyof Class]?: Class[K] extends (args: infer Argument) => unknown ? (input: unknown) => IValidation<Argument> : never;
     };
+    /**
+     * Internal type for typia transformer.
+     *
+     * @ignore
+     */
+    interface __IPrimitive<Class extends object = any> extends Omit<ILlmApplication<Class>, "config" | "functions"> {
+        functions: Omit<ILlmFunction, "parse">[];
+    }
 }

package/lib/schema/ILlmFunction.d.ts

@@ -1,22 +1,17 @@
+import { IJsonParseResult } from "./IJsonParseResult";
 import { ILlmSchema } from "./ILlmSchema";
 import { IValidation } from "./IValidation";
 /**
- * LLM function calling metadata.
+ * LLM function calling schema for TypeScript functions.
  *
- * `ILlmFunction` describes a single callable function for LLM agents. Generated
- * as part of {@link ILlmApplication} by `typia.llm.application<App>()`.
+ * Generated by `typia.llm.application<App>()` as part of
+ * {@link ILlmApplication}.
  *
- * Contains the function {@link name} (max 64 chars for OpenAI),
- * {@link parameters} schema for input types, optional {@link output} schema for
- * return type, and {@link description} for LLM to understand the function's
- * purpose.
- *
- * The built-in {@link validate} function checks LLM-generated arguments against
- * the schema, enabling auto-correction when the LLM makes type errors (e.g.,
- * returning `"123"` instead of `123`).
- *
- * Use {@link separated} when some parameters require human input (files,
- * passwords) via {@link ILlmApplication.IConfig.separate}.
+ * - {@link name}: Function identifier (max 64 chars for OpenAI)
+ * - {@link parameters}: Input schema, {@link output}: Return schema
+ * - {@link description}: Guides LLM function selection
+ * - {@link parse}: Lenient JSON parser with type coercion
+ * - {@link validate}: Argument validator for LLM error correction
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
@@ -38,20 +33,12 @@ export interface ILlmFunction {
      * parameter.
      */
     parameters: ILlmSchema.IParameters;
-    /**
-     * Parameters split between LLM and human input.
-     *
-     * Present when {@link ILlmApplication.IConfig.separate} is configured. Allows
-     * separating parameters that the LLM can fill from those requiring human
-     * input (e.g., file uploads, passwords).
-     */
-    separated?: ILlmFunction.ISeparated;
     /**
      * Schema for the return type.
      *
      * Defines the expected output type as an object parameters schema, wrapping
-     * the return type in an {@link ILlmSchema.IParameters} object with `$defs`
-     * for shared type definitions and `properties` for the structured output.
+     * the return type in an {@link ILlmSchema.IParameters} object with `$defs` for
+     * shared type definitions and `properties` for the structured output.
      *
      * `undefined` when the function returns `void` or has no meaningful return
      * value.
@@ -80,6 +67,25 @@ export interface ILlmFunction {
      * functions and filtering the function list.
      */
     tags?: string[] | undefined;
+    /**
+     * Lenient JSON parser with schema-based coercion.
+     *
+     * Handles incomplete/malformed JSON commonly produced by LLMs:
+     *
+     * - Unclosed brackets, strings, trailing commas
+     * - JavaScript-style comments (`//` and multi-line)
+     * - Unquoted object keys, incomplete keywords (`tru`, `fal`, `nul`)
+     * - Markdown code block extraction, junk prefix skipping
+     *
+     * Also coerces double-stringified values (`"42"` → `42`) using the
+     * {@link parameters} schema.
+     *
+     * Type validation is NOT performed — use {@link validate} after parsing.
+     *
+     * @param str Raw JSON string from LLM output
+     * @returns Parse result with data on success, or partial data with errors
+     */
+    parse: (str: string) => IJsonParseResult<unknown>;
     /**
      * Validates LLM-generated arguments against the schema.
      *
@@ -98,41 +104,3 @@ export interface ILlmFunction {
      */
     validate: (args: unknown) => IValidation<unknown>;
 }
-export declare namespace ILlmFunction {
-    /**
-     * Separated parameter schemas for hybrid LLM/human input.
-     *
-     * When a function has parameters that cannot or should not be filled by the
-     * LLM (e.g., file uploads, passwords, sensitive data), the parameters are
-     * split into two schemas.
-     */
-    interface ISeparated {
-        /**
-         * Parameters the LLM should fill.
-         *
-         * Contains only the parameters that are safe and appropriate for the LLM to
-         * generate values for.
-         */
-        llm: ILlmSchema.IParameters;
-        /**
-         * Parameters requiring human input.
-         *
-         * Contains parameters that must be provided by the user directly, such as
-         * file uploads, passwords, or other sensitive data. `null` when all
-         * parameters can be filled by the LLM.
-         */
-        human: ILlmSchema.IParameters | null;
-        /**
-         * Validates the LLM portion of separated parameters.
-         *
-         * Validates only the LLM-fillable portion, allowing human parameters to be
-         * validated separately with appropriate handling.
-         *
-         * When validation fails, use `stringifyValidationFailure()` from
-         * `@typia/utils` to format the error for LLM feedback.
-         *
-         * @see stringifyValidationFailure Format errors for LLM auto-correction
-         */
-        validate?: ((args: unknown) => IValidation<unknown>) | undefined;
-    }
-}

package/lib/schema/index.d.ts

@@ -9,3 +9,4 @@ export * from "./ILlmController";
 export * from "./ILlmApplication";
 export * from "./ILlmFunction";
 export * from "./ILlmSchema";
+export * from "./IJsonParseResult";

package/lib/schema/index.js

@@ -25,4 +25,5 @@ __exportStar(require("./ILlmController"), exports);
 __exportStar(require("./ILlmApplication"), exports);
 __exportStar(require("./ILlmFunction"), exports);
 __exportStar(require("./ILlmSchema"), exports);
+__exportStar(require("./IJsonParseResult"), exports);
 //# sourceMappingURL=index.js.map

package/lib/schema/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/schema/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,4CAA0B;AAC1B,gDAA8B;AAE9B,8DAA4C;AAC5C,2DAAyC;AACzC,0DAAwC;AACxC,oDAAkC;AAClC,yDAAuC;AAEvC,mDAAiC;AACjC,oDAAkC;AAClC,iDAA+B;AAC/B,+CAA6B"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/schema/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,4CAA0B;AAC1B,gDAA8B;AAE9B,8DAA4C;AAC5C,2DAAyC;AACzC,0DAAwC;AACxC,oDAAkC;AAClC,yDAAuC;AAEvC,mDAAiC;AACjC,oDAAkC;AAClC,iDAA+B;AAC/B,+CAA6B;AAC7B,qDAAmC"}

package/lib/typings/DeepPartial.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Recursively makes all properties of a type optional.
+ *
+ * `DeepPartial<T>` transforms a type by making every property optional at all
+ * nesting levels. Unlike TypeScript's built-in `Partial<T>` which only affects
+ * the top level, this utility recursively applies optionality to nested objects
+ * and arrays.
+ *
+ * Used primarily in {@link IJsonParseResult.IFailure} to represent partially
+ * recovered data from malformed JSON, where some properties may be missing due
+ * to parsing errors.
+ *
+ * Behavior:
+ *
+ * - **Primitives** (`string`, `number`, `boolean`, `bigint`, `symbol`, `null`,
+ *   `undefined`): returned as-is
+ * - **Functions**: returned as-is
+ * - **Arrays**: element type becomes `DeepPartial<U>`
+ * - **Objects**: all properties become optional with `DeepPartial` applied
+ *
+ * @author Michael - https://github.com/8471919
+ * @template T The type to make deeply partial
+ */
+export type DeepPartial<T> = T extends string | number | boolean | bigint | symbol | null | undefined ? T : T extends (...args: unknown[]) => unknown ? T : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends object ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;

package/lib/typings/DeepPartial.js

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

package/lib/typings/DeepPartial.js.map

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

package/lib/typings/index.d.ts

@@ -6,6 +6,7 @@ export * from "./Resolved";
 export * from "./SnakeCase";
 export * from "./Atomic";
 export * from "./ClassProperties";
+export * from "./DeepPartial";
 export * from "./OmitNever";
 export * from "./ProtobufAtomic";
 export * from "./SpecialFields";

package/lib/typings/index.js

@@ -22,6 +22,7 @@ __exportStar(require("./Resolved"), exports);
 __exportStar(require("./SnakeCase"), exports);
 __exportStar(require("./Atomic"), exports);
 __exportStar(require("./ClassProperties"), exports);
+__exportStar(require("./DeepPartial"), exports);
 __exportStar(require("./OmitNever"), exports);
 __exportStar(require("./ProtobufAtomic"), exports);
 __exportStar(require("./SpecialFields"), exports);

package/lib/typings/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/typings/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,mDAAiC;AACjC,8CAA4B;AAC5B,+CAA6B;AAC7B,8CAA4B;AAC5B,6CAA2B;AAC3B,8CAA4B;AAE5B,2CAAyB;AACzB,oDAAkC;AAClC,8CAA4B;AAC5B,mDAAiC;AACjC,kDAAgC;AAChC,mDAAiC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/typings/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,mDAAiC;AACjC,8CAA4B;AAC5B,+CAA6B;AAC7B,8CAA4B;AAC5B,6CAA2B;AAC3B,8CAA4B;AAE5B,2CAAyB;AACzB,oDAAkC;AAClC,gDAA8B;AAC9B,8CAA4B;AAC5B,mDAAiC;AACjC,kDAAgC;AAChC,mDAAiC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typia/interface",
-  "version": "12.0.0-dev.20260306",
+  "version": "12.0.0-dev.20260307",
   "description": "Superfast runtime validators with only one line",
   "main": "lib/index.js",
   "exports": {

package/src/http/IHttpLlmApplication.ts

@@ -19,7 +19,6 @@ import { IHttpMigrateRoute } from "./IHttpMigrateRoute";
  *
  * Configure behavior via {@link IHttpLlmApplication.IConfig}:
  *
- * - {@link IHttpLlmApplication.IConfig.separate}: Split LLM vs human parameters
  * - {@link IHttpLlmApplication.IConfig.maxLength}: Function name length limit
  * - {@link ILlmSchema.IConfig.strict}: OpenAI structured output mode
  *
@@ -38,16 +37,6 @@ export interface IHttpLlmApplication {
 export namespace IHttpLlmApplication {
   /** Configuration for HTTP LLM application composition. */
   export interface IConfig extends ILlmSchema.IConfig {
-    /**
-     * Separates parameters into LLM and human parts.
-     *
-     * Use for file uploads or sensitive data that LLM cannot handle. Return
-     * `true` for human-composed, `false` for LLM-composed.
-     *
-     * @default null
-     */
-    separate: null | ((schema: ILlmSchema) => boolean);
-
     /**
      * Maximum function name length. Truncated or UUID if exceeded.
      *

package/src/http/IHttpLlmFunction.ts

@@ -1,99 +1,34 @@
 import { OpenApi } from "../openapi/OpenApi";
-import { ILlmSchema } from "../schema/ILlmSchema";
-import { IValidation } from "../schema/IValidation";
+import { ILlmFunction } from "../schema/ILlmFunction";
 import { IHttpMigrateRoute } from "./IHttpMigrateRoute";
 
 /**
  * LLM function calling schema from OpenAPI operation.
  *
- * `IHttpLlmFunction` represents a single HTTP endpoint converted to LLM
- * function calling format. Generated from {@link OpenApi.IOperation} as part of
- * {@link IHttpLlmApplication}.
+ * Extends {@link ILlmFunction} with HTTP-specific properties. Generated from
+ * {@link OpenApi.IOperation} as part of {@link IHttpLlmApplication}.
  *
- * Key properties:
+ * - {@link method}, {@link path}: HTTP endpoint info
+ * - {@link operation}: Source OpenAPI operation
+ * - {@link route}: Source migration route
  *
- * - {@link name}: Function name (max 64 chars for OpenAI compatibility)
- * - {@link parameters}: Input schema with path/query/body merged
- * - {@link output}: Response schema (undefined if void)
- * - {@link description}: Critical for LLM function selection
- * - {@link validate}: Built-in argument validator for error feedback
- *
- * The {@link validate} function is essential: LLMs make frequent type errors
- * (e.g., `"123"` instead of `123`). Validate and retry improves success rate
- * from ~50% to 99%.
+ * Inherits {@link parse} and {@link validate} from {@link ILlmFunction}.
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export interface IHttpLlmFunction {
+export interface IHttpLlmFunction extends ILlmFunction {
   /** HTTP method of the endpoint. */
   method: "get" | "post" | "patch" | "put" | "delete";
 
   /** Path of the endpoint. */
   path: string;
 
-  /**
-   * Function name composed from {@link IHttpMigrateRoute.accessor}.
-   *
-   * @maxLength 64
-   */
-  name: string;
-
-  /**
-   * Parameter schema.
-   *
-   * With keyword mode: single object with pathParameters, query, body merged.
-   * Without keyword mode: array of [pathParameters..., query?, body?].
-   */
-  parameters: ILlmSchema.IParameters;
-
-  /**
-   * Separated parameters when {@link IHttpLlmApplication.IConfig.separate} is
-   * set.
-   */
-  separated?: IHttpLlmFunction.ISeparated;
-
-  /**
-   * Return type as an object parameters schema.
-   *
-   * Wraps the return type in an {@link ILlmSchema.IParameters} object with
-   * `$defs` for shared type definitions and `properties` for the structured
-   * output. `undefined` if the endpoint returns void.
-   */
-  output?: ILlmSchema.IParameters | undefined;
-
-  /** Function description for LLM context. Critical for function selection. */
-  description?: string | undefined;
-
-  /** Whether the function is deprecated. */
-  deprecated?: boolean | undefined;
-
   /** Category tags from {@link OpenApi.IOperation.tags}. */
   tags?: string[];
 
-  /**
-   * Validates LLM-composed arguments.
-   *
-   * LLMs frequently make type errors. Use this to provide validation feedback
-   * and retry. Success rate improves from ~50% to 99% on retry.
-   */
-  validate: (args: unknown) => IValidation<unknown>;
-
   /** Returns the source {@link OpenApi.IOperation}. */
   operation: () => OpenApi.IOperation;
 
   /** Returns the source {@link IHttpMigrateRoute}. */
   route: () => IHttpMigrateRoute;
 }
-export namespace IHttpLlmFunction {
-  /** Collection of separated parameters. */
-  export interface ISeparated {
-    /** Parameters for LLM composition. Always at least empty object. */
-    llm: ILlmSchema.IParameters;
-
-    /** Parameters for human composition. */
-    human: ILlmSchema.IParameters | null;
-
-    /** Validates separated LLM arguments. */
-    validate?: ((args: unknown) => IValidation<unknown>) | undefined;
-  }
-}

package/src/openapi/OpenApi.ts

@@ -45,7 +45,7 @@ export namespace OpenApi {
    *
    * Contains all API metadata, paths, operations, and reusable components. The
    * `x-samchon-emended-v4` marker indicates this document has been processed by
-   * `@samchon/openapi` to normalize schema formats.
+   * `samchon/typia` to normalize schema formats.
    */
   export interface IDocument {
     /** OpenAPI version. */

package/src/schema/IJsonParseResult.ts

@@ -0,0 +1,136 @@
+import { DeepPartial } from "../typings/DeepPartial";
+
+/**
+ * Result of lenient JSON parsing.
+ *
+ * `IJsonParseResult<T>` represents the result of parsing JSON that may be
+ * incomplete, malformed, or contain non-standard syntax (e.g., unquoted keys,
+ * trailing commas, missing quotes).
+ *
+ * Unlike standard JSON parsing which fails on any syntax error, lenient parsing
+ * attempts to recover as much data as possible while reporting issues.
+ *
+ * Check the {@link IJsonParseResult.success} discriminator:
+ *
+ * - `true` → {@link IJsonParseResult.ISuccess} with parsed
+ *   {@link IJsonParseResult.ISuccess.data}
+ * - `false` → {@link IJsonParseResult.IFailure} with partial
+ *   {@link IJsonParseResult.IFailure.data} and
+ *   {@link IJsonParseResult.IFailure.errors}
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @template T The expected type after successful parsing
+ */
+export type IJsonParseResult<T = unknown> =
+  | IJsonParseResult.ISuccess<T>
+  | IJsonParseResult.IFailure<T>;
+
+export namespace IJsonParseResult {
+  /**
+   * Successful parsing result.
+   *
+   * Indicates the JSON was parsed without any errors. The data may still have
+   * been recovered from non-standard syntax (e.g., unquoted keys, trailing
+   * commas), but no information was lost.
+   *
+   * @template T The parsed type
+   */
+  export interface ISuccess<T = unknown> {
+    /**
+     * Success discriminator.
+     *
+     * Always `true` for successful parsing.
+     */
+    success: true;
+
+    /** The parsed data with correct type. */
+    data: T;
+  }
+
+  /**
+   * Failed parsing result with partial data and errors.
+   *
+   * Indicates the JSON had syntax errors that could not be fully recovered. The
+   * {@link data} contains whatever could be parsed, and {@link errors} describes
+   * what went wrong.
+   *
+   * @template T The expected type (data may be partial)
+   */
+  export interface IFailure<T = unknown> {
+    /**
+     * Success discriminator.
+     *
+     * Always `false` for failed parsing.
+     */
+    success: false;
+
+    /**
+     * Partially parsed data.
+     *
+     * Contains whatever could be recovered from the malformed JSON. May be
+     * incomplete or have missing properties.
+     */
+    data: DeepPartial<T>;
+
+    /**
+     * The original input string that was parsed.
+     *
+     * Preserved for debugging or error correction purposes.
+     */
+    input: string;
+
+    /**
+     * Array of parsing errors encountered.
+     *
+     * Each error describes a specific issue found during parsing, with location
+     * and suggested fix.
+     */
+    errors: IError[];
+  }
+
+  /**
+   * Detailed information about a parsing error.
+   */
+  export interface IError {
+    /**
+     * Property path to the error location.
+     *
+     * A dot-notation path from the root to the error location. Uses `$input` as
+     * the root.
+     *
+     * @example
+     *   $input.user.email;
+     *
+     * @example
+     *   $input.items[0].price;
+     */
+    path: string;
+
+    /**
+     * What was expected at this location.
+     *
+     * @example
+     *   JSON value (string, number, boolean, null, object, or array)
+     *
+     * @example
+     *   quoted string
+     *
+     * @example
+     *   ":";
+     */
+    expected: string;
+
+    /**
+     * Description of what was actually found.
+     *
+     * Human/AI-readable message explaining the issue.
+     *
+     * @example
+     *   unquoted string 'abc' - did you forget quotes?
+     *
+     * @example
+     *   missing opening quote for 'hello'
+     */
+    value: unknown;
+  }
+}

package/src/schema/ILlmApplication.ts

@@ -11,8 +11,6 @@ import { IValidation } from "./IValidation";
  *
  * Configure behavior via {@link ILlmApplication.IConfig}:
  *
- * - {@link ILlmApplication.IConfig.separate}: Split parameters into LLM-fillable
- *   vs human-required (e.g., file uploads, passwords)
  * - {@link ILlmApplication.IConfig.validate}: Custom validation per method
  * - {@link ILlmSchema.IConfig.strict}: OpenAI structured output mode
  * - {@link ILlmSchema.IConfig.reference}: Control `$ref` inlining behavior
@@ -55,25 +53,11 @@ export namespace ILlmApplication {
    * Configuration for LLM application generation.
    *
    * Extends {@link ILlmSchema.IConfig} with application-specific options for
-   * parameter separation and custom validation. These settings control how the
-   * application schema is generated from the source class.
+   * custom validation. These settings control how the application schema is
+   * generated from the source class.
    */
   export interface IConfig<Class extends object = any>
     extends ILlmSchema.IConfig {
-    /**
-     * Function to separate LLM-fillable from human-required parameters.
-     *
-     * When provided, this function is called for each parameter schema to
-     * determine if it should be filled by the LLM (`false`) or require human
-     * input (`true`). Use this for sensitive data like passwords, file uploads,
-     * or data the LLM cannot generate.
-     *
-     * @default null (no separation)
-     * @param schema - The parameter schema to evaluate
-     * @returns `true` if human input required, `false` if LLM can fill
-     */
-    separate: null | ((schema: ILlmSchema) => boolean);
-
     /**
      * Custom validation functions per method name.
      *
@@ -100,4 +84,16 @@ export namespace ILlmApplication {
       ? (input: unknown) => IValidation<Argument>
       : never;
   };
+
+  /**
+   * Internal type for typia transformer.
+   *
+   * @ignore
+   */
+  export interface __IPrimitive<Class extends object = any> extends Omit<
+    ILlmApplication<Class>,
+    "config" | "functions"
+  > {
+    functions: Omit<ILlmFunction, "parse">[];
+  }
 }

package/src/schema/ILlmFunction.ts

@@ -1,23 +1,18 @@
+import { IJsonParseResult } from "./IJsonParseResult";
 import { ILlmSchema } from "./ILlmSchema";
 import { IValidation } from "./IValidation";
 
 /**
- * LLM function calling metadata.
+ * LLM function calling schema for TypeScript functions.
  *
- * `ILlmFunction` describes a single callable function for LLM agents. Generated
- * as part of {@link ILlmApplication} by `typia.llm.application<App>()`.
+ * Generated by `typia.llm.application<App>()` as part of
+ * {@link ILlmApplication}.
  *
- * Contains the function {@link name} (max 64 chars for OpenAI),
- * {@link parameters} schema for input types, optional {@link output} schema for
- * return type, and {@link description} for LLM to understand the function's
- * purpose.
- *
- * The built-in {@link validate} function checks LLM-generated arguments against
- * the schema, enabling auto-correction when the LLM makes type errors (e.g.,
- * returning `"123"` instead of `123`).
- *
- * Use {@link separated} when some parameters require human input (files,
- * passwords) via {@link ILlmApplication.IConfig.separate}.
+ * - {@link name}: Function identifier (max 64 chars for OpenAI)
+ * - {@link parameters}: Input schema, {@link output}: Return schema
+ * - {@link description}: Guides LLM function selection
+ * - {@link parse}: Lenient JSON parser with type coercion
+ * - {@link validate}: Argument validator for LLM error correction
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
@@ -41,21 +36,12 @@ export interface ILlmFunction {
    */
   parameters: ILlmSchema.IParameters;
 
-  /**
-   * Parameters split between LLM and human input.
-   *
-   * Present when {@link ILlmApplication.IConfig.separate} is configured. Allows
-   * separating parameters that the LLM can fill from those requiring human
-   * input (e.g., file uploads, passwords).
-   */
-  separated?: ILlmFunction.ISeparated;
-
   /**
    * Schema for the return type.
    *
    * Defines the expected output type as an object parameters schema, wrapping
-   * the return type in an {@link ILlmSchema.IParameters} object with `$defs`
-   * for shared type definitions and `properties` for the structured output.
+   * the return type in an {@link ILlmSchema.IParameters} object with `$defs` for
+   * shared type definitions and `properties` for the structured output.
    *
    * `undefined` when the function returns `void` or has no meaningful return
    * value.
@@ -88,6 +74,26 @@ export interface ILlmFunction {
    */
   tags?: string[] | undefined;
 
+  /**
+   * Lenient JSON parser with schema-based coercion.
+   *
+   * Handles incomplete/malformed JSON commonly produced by LLMs:
+   *
+   * - Unclosed brackets, strings, trailing commas
+   * - JavaScript-style comments (`//` and multi-line)
+   * - Unquoted object keys, incomplete keywords (`tru`, `fal`, `nul`)
+   * - Markdown code block extraction, junk prefix skipping
+   *
+   * Also coerces double-stringified values (`"42"` → `42`) using the
+   * {@link parameters} schema.
+   *
+   * Type validation is NOT performed — use {@link validate} after parsing.
+   *
+   * @param str Raw JSON string from LLM output
+   * @returns Parse result with data on success, or partial data with errors
+   */
+  parse: (str: string) => IJsonParseResult<unknown>;
+
   /**
    * Validates LLM-generated arguments against the schema.
    *
@@ -106,43 +112,3 @@ export interface ILlmFunction {
    */
   validate: (args: unknown) => IValidation<unknown>;
 }
-export namespace ILlmFunction {
-  /**
-   * Separated parameter schemas for hybrid LLM/human input.
-   *
-   * When a function has parameters that cannot or should not be filled by the
-   * LLM (e.g., file uploads, passwords, sensitive data), the parameters are
-   * split into two schemas.
-   */
-  export interface ISeparated {
-    /**
-     * Parameters the LLM should fill.
-     *
-     * Contains only the parameters that are safe and appropriate for the LLM to
-     * generate values for.
-     */
-    llm: ILlmSchema.IParameters;
-
-    /**
-     * Parameters requiring human input.
-     *
-     * Contains parameters that must be provided by the user directly, such as
-     * file uploads, passwords, or other sensitive data. `null` when all
-     * parameters can be filled by the LLM.
-     */
-    human: ILlmSchema.IParameters | null;
-
-    /**
-     * Validates the LLM portion of separated parameters.
-     *
-     * Validates only the LLM-fillable portion, allowing human parameters to be
-     * validated separately with appropriate handling.
-     *
-     * When validation fails, use `stringifyValidationFailure()` from
-     * `@typia/utils` to format the error for LLM feedback.
-     *
-     * @see stringifyValidationFailure Format errors for LLM auto-correction
-     */
-    validate?: ((args: unknown) => IValidation<unknown>) | undefined;
-  }
-}

package/src/schema/index.ts

@@ -11,3 +11,4 @@ export * from "./ILlmController";
 export * from "./ILlmApplication";
 export * from "./ILlmFunction";
 export * from "./ILlmSchema";
+export * from "./IJsonParseResult";

package/src/typings/DeepPartial.ts

@@ -0,0 +1,39 @@
+/**
+ * Recursively makes all properties of a type optional.
+ *
+ * `DeepPartial<T>` transforms a type by making every property optional at all
+ * nesting levels. Unlike TypeScript's built-in `Partial<T>` which only affects
+ * the top level, this utility recursively applies optionality to nested objects
+ * and arrays.
+ *
+ * Used primarily in {@link IJsonParseResult.IFailure} to represent partially
+ * recovered data from malformed JSON, where some properties may be missing due
+ * to parsing errors.
+ *
+ * Behavior:
+ *
+ * - **Primitives** (`string`, `number`, `boolean`, `bigint`, `symbol`, `null`,
+ *   `undefined`): returned as-is
+ * - **Functions**: returned as-is
+ * - **Arrays**: element type becomes `DeepPartial<U>`
+ * - **Objects**: all properties become optional with `DeepPartial` applied
+ *
+ * @author Michael - https://github.com/8471919
+ * @template T The type to make deeply partial
+ */
+export type DeepPartial<T> = T extends
+  | string
+  | number
+  | boolean
+  | bigint
+  | symbol
+  | null
+  | undefined
+  ? T
+  : T extends (...args: unknown[]) => unknown
+    ? T
+    : T extends Array<infer U>
+      ? Array<DeepPartial<U>>
+      : T extends object
+        ? { [P in keyof T]?: DeepPartial<T[P]> }
+        : T;

package/src/typings/index.ts

@@ -7,6 +7,7 @@ export * from "./SnakeCase";
 
 export * from "./Atomic";
 export * from "./ClassProperties";
+export * from "./DeepPartial";
 export * from "./OmitNever";
 export * from "./ProtobufAtomic";
 export * from "./SpecialFields";