typia 12.0.0-dev.20260310 → 12.0.0-dev.20260312

package/lib/llm.d.ts

@@ -1,4 +1,4 @@
-import { IJsonParseResult, ILlmApplication, ILlmController, ILlmSchema } from "@typia/interface";
+import { IJsonParseResult, ILlmApplication, ILlmController, ILlmSchema, ILlmStructuredOutput } from "@typia/interface";
 /**
  * Creates LLM function calling controller.
  *
@@ -91,6 +91,56 @@ export declare function application<Class extends Record<string, any>, Config ex
      */
     equals: boolean;
 }> = {}>(config?: Partial<Pick<ILlmApplication.IConfig<Class>, "validate">>): ILlmApplication<Class>;
+/**
+ * Creates LLM structured output interface.
+ *
+ * @danger You must configure the generic argument `T`
+ */
+export declare function structuredOutput(): never;
+/**
+ * Creates LLM structured output interface from TypeScript object type.
+ *
+ * Generates {@link ILlmStructuredOutput} containing everything needed for
+ * handling LLM structured outputs: the JSON schema for prompting, and functions
+ * for parsing, coercing, and validating responses.
+ *
+ * Structured outputs allow LLMs to generate data conforming to a predefined
+ * schema instead of free-form text. This is useful for:
+ *
+ * - Extracting structured data from conversations
+ * - Generating typed responses for downstream processing
+ * - Ensuring consistent output formats across LLM calls
+ *
+ * Workflow:
+ *
+ * 1. Pass {@link ILlmStructuredOutput.parameters} schema to LLM provider
+ * 2. Receive LLM response (JSON string or pre-parsed object)
+ * 3. Use {@link ILlmStructuredOutput.parse} for raw strings or
+ *    {@link ILlmStructuredOutput.coerce} for pre-parsed objects
+ * 4. Use {@link ILlmStructuredOutput.validate} to check the result
+ *
+ * Related functions:
+ *
+ * - {@link parameters} — Schema only, without parse/coerce/validate
+ * - {@link application} — Multiple function schemas from class/interface
+ * - {@link controller} — Application with executor
+ *
+ * @template T Target output type (object with static properties)
+ * @template Config LLM schema configuration
+ * @returns LLM structured output interface
+ */
+export declare function structuredOutput<T extends Record<string, any>, Config extends Partial<ILlmSchema.IConfig & {
+    /**
+     * Whether to disallow superfluous properties or not.
+     *
+     * If configure as `true`, {@link validateEquals} function would be used
+     * for validation feedback, which is more strict than {@link validate}
+     * function.
+     *
+     * @default false
+     */
+    equals: boolean;
+}> = {}>(): ILlmStructuredOutput<T>;
 /**
  * Creates LLM parameters schema.
  *

package/lib/llm.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.controller = controller;
 exports.application = application;
+exports.structuredOutput = structuredOutput;
 exports.parameters = parameters;
 exports.schema = schema;
 exports.parse = parse;
@@ -18,6 +19,10 @@ function application() {
     (0, NoTransformConfigurationError_1.NoTransformConfigurationError)("llm.application");
 }
 /** @internal */
+function structuredOutput() {
+    (0, NoTransformConfigurationError_1.NoTransformConfigurationError)("llm.structuredOutput");
+}
+/** @internal */
 function parameters() {
     (0, NoTransformConfigurationError_1.NoTransformConfigurationError)("llm.parameters");
 }

package/lib/llm.js.map

@@ -1 +1 @@
-{"version":3,"file":"llm.js","sourceRoot":"","sources":["../src/llm.ts"],"names":[],"mappings":";;AAwEA,gCAEC;AA2DD,kCAEC;AAqCD,gCAEC;AAuCD,wBAEC;AAkDD,sBAEC;AAwCD,wBAEC;AAkDD,kCAEC;AA4CD,oCAEC;AAhZD,gGAA6F;AAgE7F,gBAAgB;AAChB,SAAgB,UAAU,CAAC,GAAG,KAAY;IACxC,IAAA,6DAA6B,EAAC,gBAAgB,CAAC,CAAC;AAClD,CAAC;AA0DD,gBAAgB;AAChB,SAAgB,WAAW;IACzB,IAAA,6DAA6B,EAAC,iBAAiB,CAAC,CAAC;AACnD,CAAC;AAoCD,gBAAgB;AAChB,SAAgB,UAAU;IACxB,IAAA,6DAA6B,EAAC,gBAAgB,CAAC,CAAC;AAClD,CAAC;AAsCD,gBAAgB;AAChB,SAAgB,MAAM;IACpB,IAAA,6DAA6B,EAAC,YAAY,CAAC,CAAC;AAC9C,CAAC;AAiDD,gBAAgB;AAChB,SAAgB,KAAK;IACnB,IAAA,6DAA6B,EAAC,WAAW,CAAC,CAAC;AAC7C,CAAC;AAuCD,gBAAgB;AAChB,SAAgB,MAAM;IACpB,IAAA,6DAA6B,EAAC,YAAY,CAAC,CAAC;AAC9C,CAAC;AAiDD,gBAAgB;AAChB,SAAgB,WAAW;IACzB,IAAA,6DAA6B,EAAC,iBAAiB,CAAC,CAAC;AACnD,CAAC;AA2CD,gBAAgB;AAChB,SAAgB,YAAY;IAC1B,IAAA,6DAA6B,EAAC,kBAAkB,CAAC,CAAC;AACpD,CAAC"}
+{"version":3,"file":"llm.js","sourceRoot":"","sources":["../src/llm.ts"],"names":[],"mappings":";;AA4EA,gCAEC;AA2DD,kCAEC;AA4DD,4CAEC;AAwCD,gCAEC;AAuCD,wBAEC;AAqDD,sBAEC;AAwCD,wBAEC;AAkDD,kCAEC;AA4CD,oCAEC;AAvdD,gGAA6F;AAmE7F,gBAAgB;AAChB,SAAgB,UAAU,CAAC,GAAG,KAAY;IACxC,IAAA,6DAA6B,EAAC,gBAAgB,CAAC,CAAC;AAClD,CAAC;AA0DD,gBAAgB;AAChB,SAAgB,WAAW;IACzB,IAAA,6DAA6B,EAAC,iBAAiB,CAAC,CAAC;AACnD,CAAC;AA2DD,gBAAgB;AAChB,SAAgB,gBAAgB;IAC9B,IAAA,6DAA6B,EAAC,sBAAsB,CAAC,CAAC;AACxD,CAAC;AAuCD,gBAAgB;AAChB,SAAgB,UAAU;IACxB,IAAA,6DAA6B,EAAC,gBAAgB,CAAC,CAAC;AAClD,CAAC;AAsCD,gBAAgB;AAChB,SAAgB,MAAM;IACpB,IAAA,6DAA6B,EAAC,YAAY,CAAC,CAAC;AAC9C,CAAC;AAoDD,gBAAgB;AAChB,SAAgB,KAAK;IACnB,IAAA,6DAA6B,EAAC,WAAW,CAAC,CAAC;AAC7C,CAAC;AAuCD,gBAAgB;AAChB,SAAgB,MAAM;IACpB,IAAA,6DAA6B,EAAC,YAAY,CAAC,CAAC;AAC9C,CAAC;AAiDD,gBAAgB;AAChB,SAAgB,WAAW;IACzB,IAAA,6DAA6B,EAAC,iBAAiB,CAAC,CAAC;AACnD,CAAC;AA2CD,gBAAgB;AAChB,SAAgB,YAAY;IAC1B,IAAA,6DAA6B,EAAC,kBAAkB,CAAC,CAAC;AACpD,CAAC"}

package/lib/llm.mjs

@@ -9,6 +9,10 @@ function application() {
     NoTransformConfigurationError("llm.application");
 }
 /** @internal */
+function structuredOutput() {
+    NoTransformConfigurationError("llm.structuredOutput");
+}
+/** @internal */
 function parameters() {
     NoTransformConfigurationError("llm.parameters");
 }
@@ -33,5 +37,5 @@ function createCoerce() {
     NoTransformConfigurationError("llm.createCoerce");
 }
 
-export { application, coerce, controller, createCoerce, createParse, parameters, parse, schema };
+export { application, coerce, controller, createCoerce, createParse, parameters, parse, schema, structuredOutput };
 //# sourceMappingURL=llm.mjs.map

package/lib/llm.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"llm.mjs","sources":["../src/llm.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAuEA;AACM,SAAU,UAAU,CAAC,GAAG,KAAY,EAAA;IACxC,6BAA6B,CAAC,gBAAgB,CAAC;AACjD;AA0DA;SACgB,WAAW,GAAA;IACzB,6BAA6B,CAAC,iBAAiB,CAAC;AAClD;AAoCA;SACgB,UAAU,GAAA;IACxB,6BAA6B,CAAC,gBAAgB,CAAC;AACjD;AAsCA;SACgB,MAAM,GAAA;IACpB,6BAA6B,CAAC,YAAY,CAAC;AAC7C;AAiDA;SACgB,KAAK,GAAA;IACnB,6BAA6B,CAAC,WAAW,CAAC;AAC5C;AAuCA;SACgB,MAAM,GAAA;IACpB,6BAA6B,CAAC,YAAY,CAAC;AAC7C;AAiDA;SACgB,WAAW,GAAA;IACzB,6BAA6B,CAAC,iBAAiB,CAAC;AAClD;AA2CA;SACgB,YAAY,GAAA;IAC1B,6BAA6B,CAAC,kBAAkB,CAAC;AACnD;;;;"}
+{"version":3,"file":"llm.mjs","sources":["../src/llm.ts"],"sourcesContent":[null],"names":[],"mappings":";;AA2EA;AACM,SAAU,UAAU,CAAC,GAAG,KAAY,EAAA;IACxC,6BAA6B,CAAC,gBAAgB,CAAC;AACjD;AA0DA;SACgB,WAAW,GAAA;IACzB,6BAA6B,CAAC,iBAAiB,CAAC;AAClD;AA2DA;SACgB,gBAAgB,GAAA;IAC9B,6BAA6B,CAAC,sBAAsB,CAAC;AACvD;AAuCA;SACgB,UAAU,GAAA;IACxB,6BAA6B,CAAC,gBAAgB,CAAC;AACjD;AAsCA;SACgB,MAAM,GAAA;IACpB,6BAA6B,CAAC,YAAY,CAAC;AAC7C;AAoDA;SACgB,KAAK,GAAA;IACnB,6BAA6B,CAAC,WAAW,CAAC;AAC5C;AAuCA;SACgB,MAAM,GAAA;IACpB,6BAA6B,CAAC,YAAY,CAAC;AAC7C;AAiDA;SACgB,WAAW,GAAA;IACzB,6BAA6B,CAAC,iBAAiB,CAAC;AAClD;AA2CA;SACgB,YAAY,GAAA;IAC1B,6BAA6B,CAAC,kBAAkB,CAAC;AACnD;;;;"}

package/lib/re-exports.d.ts

@@ -1 +1 @@
-export { AssertionGuard, IJsonParseResult, IValidation, IRandomGenerator, OpenApi, IJsonSchemaCollection, IJsonSchemaUnit, ILlmController, ILlmApplication, ILlmFunction, ILlmSchema, IMetadataSchema, IMetadataSchemaCollection, IMetadataSchemaUnit, IMetadataComponents, IMetadataTypeTag, IJsDocTagInfo, Primitive, Resolved, CamelCase, PascalCase, SnakeCase, IReadableURLSearchParams, tags, } from "@typia/interface";
+export { AssertionGuard, IJsonParseResult, IValidation, IRandomGenerator, OpenApi, IJsonSchemaCollection, IJsonSchemaUnit, ILlmController, ILlmApplication, ILlmFunction, ILlmStructuredOutput, ILlmSchema, IMetadataSchema, IMetadataSchemaCollection, IMetadataSchemaUnit, IMetadataComponents, IMetadataTypeTag, IJsDocTagInfo, Primitive, Resolved, CamelCase, PascalCase, SnakeCase, IReadableURLSearchParams, tags, } from "@typia/interface";

package/lib/re-exports.js.map

@@ -1 +1 @@
-{"version":3,"file":"re-exports.js","sourceRoot":"","sources":["../src/re-exports.ts"],"names":[],"mappings":";;;AAAA,8CAgC0B;AAFxB,aAAa;AACb,iGAAA,IAAI,OAAA"}
+{"version":3,"file":"re-exports.js","sourceRoot":"","sources":["../src/re-exports.ts"],"names":[],"mappings":";;;AAAA,8CAiC0B;AAFxB,aAAa;AACb,iGAAA,IAAI,OAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typia",
-  "version": "12.0.0-dev.20260310",
+  "version": "12.0.0-dev.20260312",
   "description": "Superfast runtime validators with only one line",
   "main": "lib/index.js",
   "exports": {
@@ -50,10 +50,10 @@
     "inquirer": "^8.2.5",
     "package-manager-detector": "^0.2.0",
     "randexp": "^0.5.3",
-    "@typia/interface": "^12.0.0-dev.20260310",
-    "@typia/utils": "^12.0.0-dev.20260310",
-    "@typia/core": "^12.0.0-dev.20260310",
-    "@typia/transform": "^12.0.0-dev.20260310"
+    "@typia/transform": "^12.0.0-dev.20260312",
+    "@typia/utils": "^12.0.0-dev.20260312",
+    "@typia/interface": "^12.0.0-dev.20260312",
+    "@typia/core": "^12.0.0-dev.20260312"
   },
   "peerDependencies": {
     "typescript": ">=4.8.0 <5.10.0"

package/src/llm.ts

@@ -1,408 +1,480 @@
-import {
-  IJsonParseResult,
-  ILlmApplication,
-  ILlmController,
-  ILlmSchema,
-} from "@typia/interface";
-
-import { NoTransformConfigurationError } from "./transformers/NoTransformConfigurationError";
-
-/**
- * Creates LLM function calling controller.
- *
- * @danger You must configure the generic argument `Class`
- */
-export function controller(
-  name: string,
-  execute: object,
-  config?: Partial<Pick<ILlmApplication.IConfig<any>, "validate">>,
-): never;
-
-/**
- * Creates LLM function calling controller from class/interface.
- *
- * Generates {@link ILlmController} from a TypeScript class or interface,
- * containing both function calling schemas ({@link ILlmFunction}) and an
- * executor ({@link ILlmController.execute}).
- *
- * Each {@link ILlmFunction} includes a built-in {@link ILlmFunction.validate}
- * function that validates LLM-generated arguments before execution. When
- * validation fails, use `LlmJson.stringify()` from `@typia/utils` to format
- * errors for LLM feedback, enabling auto-correction.
- *
- * When passed to LLM providers (ChatGPT, Claude, Gemini, etc.), the LLM
- * automatically selects functions and fills arguments from conversation.
- * Execute the selected function via {@link ILlmController.execute}.
- *
- * Related functions:
- *
- * - {@link application} — Schemas only, without executor
- * - {@link parameters} — Single parameters schema for structured output
- * - {@link schema} — Single type schema
- *
- * @template Class Target class or interface type
- * @template Config LLM schema configuration
- * @param name Controller identifier name
- * @param execute Executor instance
- * @param config LLM application options
- * @returns LLM function calling controller
- */
-export function controller<
-  Class extends Record<string, any>,
-  Config extends Partial<
-    ILlmSchema.IConfig & {
-      /**
-       * Whether to disallow superfluous properties or not.
-       *
-       * If configure as `true`, {@link validateEquals} function would be used
-       * for validation feedback, which is more strict than {@link validate}
-       * function.
-       *
-       * @default false
-       */
-      equals: boolean;
-    }
-  > = {},
->(
-  name: string,
-  execute: Class,
-  config?: Partial<Pick<ILlmApplication.IConfig<Class>, "validate">>,
-): ILlmController<Class>;
-
-/** @internal */
-export function controller(..._args: any[]): never {
-  NoTransformConfigurationError("llm.controller");
-}
-
-/**
- * Creates LLM function calling application.
- *
- * @danger You must configure the generic argument `Class`
- */
-export function application(
-  config?: Partial<Pick<ILlmApplication.IConfig<any>, "validate">>,
-): never;
-
-/**
- * Creates LLM function calling application from class/interface.
- *
- * Generates {@link ILlmApplication} from a TypeScript class or interface,
- * containing function calling schemas ({@link ILlmFunction}). Does not include
- * an executor—use {@link controller} if you need execution capability.
- *
- * Each {@link ILlmFunction} includes a built-in {@link ILlmFunction.validate}
- * function that validates LLM-generated arguments before execution. When
- * validation fails, use `LlmJson.stringify()` from `@typia/utils` to format
- * errors for LLM feedback, enabling auto-correction.
- *
- * When passed to LLM providers (ChatGPT, Claude, Gemini, etc.), the LLM
- * automatically selects functions and fills arguments from conversation. You
- * execute the function manually with the LLM-prepared arguments.
- *
- * Related functions:
- *
- * - {@link controller} — Includes executor alongside schemas
- * - {@link parameters} — Single parameters schema for structured output
- * - {@link schema} — Single type schema
- *
- * @template Class Target class or interface type
- * @template Config LLM schema configuration
- * @param config LLM application options
- * @returns LLM function calling application
- */
-export function application<
-  Class extends Record<string, any>,
-  Config extends Partial<
-    ILlmSchema.IConfig & {
-      /**
-       * Whether to disallow superfluous properties or not.
-       *
-       * If configure as `true`, {@link validateEquals} function would be used
-       * for validation feedback, which is more strict than {@link validate}
-       * function.
-       *
-       * @default false
-       */
-      equals: boolean;
-    }
-  > = {},
->(
-  config?: Partial<Pick<ILlmApplication.IConfig<Class>, "validate">>,
-): ILlmApplication<Class>;
-
-/** @internal */
-export function application(): never {
-  NoTransformConfigurationError("llm.application");
-}
-
-/**
- * Creates LLM parameters schema.
- *
- * @danger You must configure the generic argument `Parameters`
- */
-export function parameters(): never;
-
-/**
- * Creates LLM parameters schema from TypeScript object type.
- *
- * Generates {@link ILlmSchema.IParameters} for LLM function calling or
- * structured outputs. LLMs use keyworded arguments only, so the type must be an
- * object with static properties (no dynamic properties allowed).
- *
- * Use cases:
- *
- * - Function calling: LLM fills parameters from conversation
- * - Structured outputs: LLM generates structured data, not plain text
- *
- * Related functions:
- *
- * - {@link application} — Multiple function schemas from class/interface
- * - {@link controller} — Application with executor
- * - {@link schema} — Single type schema (not parameters-specific)
- *
- * @template Parameters Target parameters type (object with static properties)
- * @template Config LLM schema configuration
- * @returns LLM parameters schema
- */
-export function parameters<
-  Parameters extends Record<string, any>,
-  Config extends Partial<ILlmSchema.IConfig> = {},
->(): ILlmSchema.IParameters;
-
-/** @internal */
-export function parameters(): never {
-  NoTransformConfigurationError("llm.parameters");
-}
-
-/**
- * Creates LLM type schema.
- *
- * @danger You must configure the generic argument `T`
- */
-export function schema(): never;
-
-/**
- * Creates LLM type schema from TypeScript type.
- *
- * Generates {@link ILlmSchema} for use in LLM function calling. For actual
- * function calling with TypeScript functions, use {@link application}. For
- * structured output generation, use {@link parameters}.
- *
- * LLM function calling flow:
- *
- * 1. LLM selects function and fills arguments from conversation
- * 2. You execute the function with LLM-prepared arguments
- * 3. Return value is passed back to LLM via system prompt
- * 4. LLM continues conversation based on return value
- *
- * Related functions:
- *
- * - {@link application} — Multiple function schemas from class/interface
- * - {@link controller} — Application with executor
- * - {@link parameters} — Parameters schema for structured output
- *
- * @template T Target type
- * @template Config LLM schema configuration
- * @param $defs Shared schema definitions for `$ref` referencing
- * @returns LLM type schema
- */
-export function schema<T, Config extends Partial<ILlmSchema.IConfig> = {}>(
-  $defs: Record<string, ILlmSchema>,
-): ILlmSchema;
-
-/** @internal */
-export function schema(): never {
-  NoTransformConfigurationError("llm.schema");
-}
-
-/**
- * Parse LLM response JSON with type coercion.
- *
- * @danger You must configure the generic argument `Parameters`
- */
-export function parse(input: string): never;
-
-/**
- * Parse lenient JSON with schema-based type coercion.
- *
- * Handles incomplete or 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 based on the `Parameters` schema:
- *
- * - `"42"` → `42` (when schema expects number)
- * - `"true"` → `true` (when schema expects boolean)
- * - `"null"` → `null` (when schema expects null)
- * - `"{...}"` → `{...}` (when schema expects object)
- * - `"[...]"` → `[...]` (when schema expects array)
- *
- * Type validation is NOT performed—use {@link ILlmFunction.validate} or
- * `typia.validate()` for that.
- *
- * For repeated parsing, use {@link createParse} to avoid regenerating the schema
- * each time.
- *
- * Related functions:
- *
- * - {@link createParse} — Create reusable parser function
- * - {@link coerce} — Type coercion for already-parsed objects
- * - {@link parameters} — Generate parameters schema from type
- *
- * @template Parameters Target parameters type (object with static properties)
- * @template Config LLM schema configuration
- * @param input Raw JSON string (potentially incomplete or malformed)
- * @returns Parse result with typed data on success, or partial data with errors
- */
-export function parse<
-  Parameters extends Record<string, any>,
-  Config extends Partial<ILlmSchema.IConfig> = {},
->(input: string): IJsonParseResult<Parameters>;
-
-/** @internal */
-export function parse(): never {
-  NoTransformConfigurationError("llm.parse");
-}
-
-/**
- * Coerce LLM arguments to match expected schema types.
- *
- * LLMs often return values with incorrect types (e.g., numbers as strings).
- * This function recursively coerces values based on the `Parameters` schema:
- *
- * - `"42"` → `42` (when schema expects number)
- * - `"true"` → `true` (when schema expects boolean)
- * - `"null"` → `null` (when schema expects null)
- * - `"{...}"` → `{...}` (when schema expects object)
- * - `"[...]"` → `[...]` (when schema expects array)
- *
- * Use this when your SDK provides already-parsed objects but values may have
- * wrong types. For raw JSON strings, use {@link parse} instead.
- *
- * For repeated coercion, use {@link createCoerce} to avoid regenerating the
- * schema each time.
- *
- * Type validation is NOT performed—use {@link ILlmFunction.validate} or
- * `typia.validate()` for that.
- *
- * Related functions:
- *
- * - {@link createCoerce} — Create reusable coercer function
- * - {@link parse} — Parse and coerce raw JSON strings
- * - {@link parameters} — Generate parameters schema from type
- *
- * @template Parameters Target parameters type (object with static properties)
- * @template Config LLM schema configuration
- * @param input Parsed arguments object from LLM (with potentially wrong types)
- * @returns Coerced arguments with corrected types
- */
-export function coerce<
-  Parameters extends Record<string, any>,
-  Config extends Partial<ILlmSchema.IConfig> = {},
->(input: Parameters): Parameters;
-
-/** @internal */
-export function coerce(): never {
-  NoTransformConfigurationError("llm.coerce");
-}
-
-/**
- * Create reusable LLM JSON parser with type coercion.
- *
- * @danger You must configure the generic argument `Parameters`
- */
-export function createParse(): never;
-
-/**
- * Create reusable lenient JSON parser with schema-based type coercion.
- *
- * Returns a parser function that handles incomplete or 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 based on the `Parameters` schema:
- *
- * - `"42"` → `42` (when schema expects number)
- * - `"true"` → `true` (when schema expects boolean)
- * - `"null"` → `null` (when schema expects null)
- * - `"{...}"` → `{...}` (when schema expects object)
- * - `"[...]"` → `[...]` (when schema expects array)
- *
- * Use this instead of {@link parse} when parsing multiple inputs to avoid
- * regenerating the schema each time.
- *
- * Type validation is NOT performed—use {@link ILlmFunction.validate} or
- * `typia.validate()` for that.
- *
- * Related functions:
- *
- * - {@link parse} — One-shot parsing (regenerates schema each call)
- * - {@link createCoerce} — Create reusable coercer function
- * - {@link parameters} — Generate parameters schema from type
- *
- * @template Parameters Target parameters type (object with static properties)
- * @template Config LLM schema configuration
- * @returns Reusable parser function
- */
-export function createParse<
-  Parameters extends Record<string, any>,
-  Config extends Partial<ILlmSchema.IConfig> = {},
->(): (input: string) => IJsonParseResult<Parameters>;
-
-/** @internal */
-export function createParse(): never {
-  NoTransformConfigurationError("llm.createParse");
-}
-
-/**
- * Create reusable LLM arguments coercer.
- *
- * @danger You must configure the generic argument `Parameters`
- */
-export function createCoerce(): never;
-
-/**
- * Create reusable coercer for LLM arguments.
- *
- * Returns a coercer function that fixes incorrect types commonly returned by
- * LLMs (e.g., numbers as strings). Coerces values based on the `Parameters`
- * schema:
- *
- * - `"42"` → `42` (when schema expects number)
- * - `"true"` → `true` (when schema expects boolean)
- * - `"null"` → `null` (when schema expects null)
- * - `"{...}"` → `{...}` (when schema expects object)
- * - `"[...]"` → `[...]` (when schema expects array)
- *
- * Use this instead of {@link coerce} when coercing multiple inputs to avoid
- * regenerating the schema each time.
- *
- * Type validation is NOT performed—use {@link ILlmFunction.validate} or
- * `typia.validate()` for that.
- *
- * Related functions:
- *
- * - {@link coerce} — One-shot coercion (regenerates schema each call)
- * - {@link createParse} — Create reusable parser function
- * - {@link parameters} — Generate parameters schema from type
- *
- * @template Parameters Target parameters type (object with static properties)
- * @template Config LLM schema configuration
- * @returns Reusable coercer function
- */
-export function createCoerce<
-  Parameters extends Record<string, any>,
-  Config extends Partial<ILlmSchema.IConfig> = {},
->(): (input: Parameters) => Parameters;
-
-/** @internal */
-export function createCoerce(): never {
-  NoTransformConfigurationError("llm.createCoerce");
-}
+import {
+  IJsonParseResult,
+  ILlmApplication,
+  ILlmController,
+  ILlmSchema,
+  ILlmStructuredOutput,
+} from "@typia/interface";
+
+import { NoTransformConfigurationError } from "./transformers/NoTransformConfigurationError";
+
+/* -----------------------------------------------------------
+  FUNCTION CALLING
+----------------------------------------------------------- */
+/**
+ * Creates LLM function calling controller.
+ *
+ * @danger You must configure the generic argument `Class`
+ */
+export function controller(
+  name: string,
+  execute: object,
+  config?: Partial<Pick<ILlmApplication.IConfig<any>, "validate">>,
+): never;
+
+/**
+ * Creates LLM function calling controller from class/interface.
+ *
+ * Generates {@link ILlmController} from a TypeScript class or interface,
+ * containing both function calling schemas ({@link ILlmFunction}) and an
+ * executor ({@link ILlmController.execute}).
+ *
+ * Each {@link ILlmFunction} includes a built-in {@link ILlmFunction.validate}
+ * function that validates LLM-generated arguments before execution. When
+ * validation fails, use `LlmJson.stringify()` from `@typia/utils` to format
+ * errors for LLM feedback, enabling auto-correction.
+ *
+ * When passed to LLM providers (ChatGPT, Claude, Gemini, etc.), the LLM
+ * automatically selects functions and fills arguments from conversation.
+ * Execute the selected function via {@link ILlmController.execute}.
+ *
+ * Related functions:
+ *
+ * - {@link application} — Schemas only, without executor
+ * - {@link parameters} — Single parameters schema for structured output
+ * - {@link schema} — Single type schema
+ *
+ * @template Class Target class or interface type
+ * @template Config LLM schema configuration
+ * @param name Controller identifier name
+ * @param execute Executor instance
+ * @param config LLM application options
+ * @returns LLM function calling controller
+ */
+export function controller<
+  Class extends Record<string, any>,
+  Config extends Partial<
+    ILlmSchema.IConfig & {
+      /**
+       * Whether to disallow superfluous properties or not.
+       *
+       * If configure as `true`, {@link validateEquals} function would be used
+       * for validation feedback, which is more strict than {@link validate}
+       * function.
+       *
+       * @default false
+       */
+      equals: boolean;
+    }
+  > = {},
+>(
+  name: string,
+  execute: Class,
+  config?: Partial<Pick<ILlmApplication.IConfig<Class>, "validate">>,
+): ILlmController<Class>;
+
+/** @internal */
+export function controller(..._args: any[]): never {
+  NoTransformConfigurationError("llm.controller");
+}
+
+/**
+ * Creates LLM function calling application.
+ *
+ * @danger You must configure the generic argument `Class`
+ */
+export function application(
+  config?: Partial<Pick<ILlmApplication.IConfig<any>, "validate">>,
+): never;
+
+/**
+ * Creates LLM function calling application from class/interface.
+ *
+ * Generates {@link ILlmApplication} from a TypeScript class or interface,
+ * containing function calling schemas ({@link ILlmFunction}). Does not include
+ * an executor—use {@link controller} if you need execution capability.
+ *
+ * Each {@link ILlmFunction} includes a built-in {@link ILlmFunction.validate}
+ * function that validates LLM-generated arguments before execution. When
+ * validation fails, use `LlmJson.stringify()` from `@typia/utils` to format
+ * errors for LLM feedback, enabling auto-correction.
+ *
+ * When passed to LLM providers (ChatGPT, Claude, Gemini, etc.), the LLM
+ * automatically selects functions and fills arguments from conversation. You
+ * execute the function manually with the LLM-prepared arguments.
+ *
+ * Related functions:
+ *
+ * - {@link controller} — Includes executor alongside schemas
+ * - {@link parameters} — Single parameters schema for structured output
+ * - {@link schema} — Single type schema
+ *
+ * @template Class Target class or interface type
+ * @template Config LLM schema configuration
+ * @param config LLM application options
+ * @returns LLM function calling application
+ */
+export function application<
+  Class extends Record<string, any>,
+  Config extends Partial<
+    ILlmSchema.IConfig & {
+      /**
+       * Whether to disallow superfluous properties or not.
+       *
+       * If configure as `true`, {@link validateEquals} function would be used
+       * for validation feedback, which is more strict than {@link validate}
+       * function.
+       *
+       * @default false
+       */
+      equals: boolean;
+    }
+  > = {},
+>(
+  config?: Partial<Pick<ILlmApplication.IConfig<Class>, "validate">>,
+): ILlmApplication<Class>;
+
+/** @internal */
+export function application(): never {
+  NoTransformConfigurationError("llm.application");
+}
+
+/**
+ * Creates LLM structured output interface.
+ *
+ * @danger You must configure the generic argument `T`
+ */
+export function structuredOutput(): never;
+
+/**
+ * Creates LLM structured output interface from TypeScript object type.
+ *
+ * Generates {@link ILlmStructuredOutput} containing everything needed for
+ * handling LLM structured outputs: the JSON schema for prompting, and functions
+ * for parsing, coercing, and validating responses.
+ *
+ * Structured outputs allow LLMs to generate data conforming to a predefined
+ * schema instead of free-form text. This is useful for:
+ *
+ * - Extracting structured data from conversations
+ * - Generating typed responses for downstream processing
+ * - Ensuring consistent output formats across LLM calls
+ *
+ * Workflow:
+ *
+ * 1. Pass {@link ILlmStructuredOutput.parameters} schema to LLM provider
+ * 2. Receive LLM response (JSON string or pre-parsed object)
+ * 3. Use {@link ILlmStructuredOutput.parse} for raw strings or
+ *    {@link ILlmStructuredOutput.coerce} for pre-parsed objects
+ * 4. Use {@link ILlmStructuredOutput.validate} to check the result
+ *
+ * Related functions:
+ *
+ * - {@link parameters} — Schema only, without parse/coerce/validate
+ * - {@link application} — Multiple function schemas from class/interface
+ * - {@link controller} — Application with executor
+ *
+ * @template T Target output type (object with static properties)
+ * @template Config LLM schema configuration
+ * @returns LLM structured output interface
+ */
+export function structuredOutput<
+  T extends Record<string, any>,
+  Config extends Partial<
+    ILlmSchema.IConfig & {
+      /**
+       * Whether to disallow superfluous properties or not.
+       *
+       * If configure as `true`, {@link validateEquals} function would be used
+       * for validation feedback, which is more strict than {@link validate}
+       * function.
+       *
+       * @default false
+       */
+      equals: boolean;
+    }
+  > = {},
+>(): ILlmStructuredOutput<T>;
+
+/** @internal */
+export function structuredOutput(): never {
+  NoTransformConfigurationError("llm.structuredOutput");
+}
+
+/* -----------------------------------------------------------
+  RAW SCHEMAS
+----------------------------------------------------------- */
+/**
+ * Creates LLM parameters schema.
+ *
+ * @danger You must configure the generic argument `Parameters`
+ */
+export function parameters(): never;
+
+/**
+ * Creates LLM parameters schema from TypeScript object type.
+ *
+ * Generates {@link ILlmSchema.IParameters} for LLM function calling or
+ * structured outputs. LLMs use keyworded arguments only, so the type must be an
+ * object with static properties (no dynamic properties allowed).
+ *
+ * Use cases:
+ *
+ * - Function calling: LLM fills parameters from conversation
+ * - Structured outputs: LLM generates structured data, not plain text
+ *
+ * Related functions:
+ *
+ * - {@link application} — Multiple function schemas from class/interface
+ * - {@link controller} — Application with executor
+ * - {@link schema} — Single type schema (not parameters-specific)
+ *
+ * @template Parameters Target parameters type (object with static properties)
+ * @template Config LLM schema configuration
+ * @returns LLM parameters schema
+ */
+export function parameters<
+  Parameters extends Record<string, any>,
+  Config extends Partial<ILlmSchema.IConfig> = {},
+>(): ILlmSchema.IParameters;
+
+/** @internal */
+export function parameters(): never {
+  NoTransformConfigurationError("llm.parameters");
+}
+
+/**
+ * Creates LLM type schema.
+ *
+ * @danger You must configure the generic argument `T`
+ */
+export function schema(): never;
+
+/**
+ * Creates LLM type schema from TypeScript type.
+ *
+ * Generates {@link ILlmSchema} for use in LLM function calling. For actual
+ * function calling with TypeScript functions, use {@link application}. For
+ * structured output generation, use {@link parameters}.
+ *
+ * LLM function calling flow:
+ *
+ * 1. LLM selects function and fills arguments from conversation
+ * 2. You execute the function with LLM-prepared arguments
+ * 3. Return value is passed back to LLM via system prompt
+ * 4. LLM continues conversation based on return value
+ *
+ * Related functions:
+ *
+ * - {@link application} — Multiple function schemas from class/interface
+ * - {@link controller} — Application with executor
+ * - {@link parameters} — Parameters schema for structured output
+ *
+ * @template T Target type
+ * @template Config LLM schema configuration
+ * @param $defs Shared schema definitions for `$ref` referencing
+ * @returns LLM type schema
+ */
+export function schema<T, Config extends Partial<ILlmSchema.IConfig> = {}>(
+  $defs: Record<string, ILlmSchema>,
+): ILlmSchema;
+
+/** @internal */
+export function schema(): never {
+  NoTransformConfigurationError("llm.schema");
+}
+
+/* -----------------------------------------------------------
+  UTILITY FUNCTIONS
+----------------------------------------------------------- */
+/**
+ * Parse LLM response JSON with type coercion.
+ *
+ * @danger You must configure the generic argument `Parameters`
+ */
+export function parse(input: string): never;
+
+/**
+ * Parse lenient JSON with schema-based type coercion.
+ *
+ * Handles incomplete or 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 based on the `Parameters` schema:
+ *
+ * - `"42"` → `42` (when schema expects number)
+ * - `"true"` → `true` (when schema expects boolean)
+ * - `"null"` → `null` (when schema expects null)
+ * - `"{...}"` → `{...}` (when schema expects object)
+ * - `"[...]"` → `[...]` (when schema expects array)
+ *
+ * Type validation is NOT performed—use {@link ILlmFunction.validate} or
+ * `typia.validate()` for that.
+ *
+ * For repeated parsing, use {@link createParse} to avoid regenerating the schema
+ * each time.
+ *
+ * Related functions:
+ *
+ * - {@link createParse} — Create reusable parser function
+ * - {@link coerce} — Type coercion for already-parsed objects
+ * - {@link parameters} — Generate parameters schema from type
+ *
+ * @template Parameters Target parameters type (object with static properties)
+ * @template Config LLM schema configuration
+ * @param input Raw JSON string (potentially incomplete or malformed)
+ * @returns Parse result with typed data on success, or partial data with errors
+ */
+export function parse<
+  Parameters extends Record<string, any>,
+  Config extends Partial<ILlmSchema.IConfig> = {},
+>(input: string): IJsonParseResult<Parameters>;
+
+/** @internal */
+export function parse(): never {
+  NoTransformConfigurationError("llm.parse");
+}
+
+/**
+ * Coerce LLM arguments to match expected schema types.
+ *
+ * LLMs often return values with incorrect types (e.g., numbers as strings).
+ * This function recursively coerces values based on the `Parameters` schema:
+ *
+ * - `"42"` → `42` (when schema expects number)
+ * - `"true"` → `true` (when schema expects boolean)
+ * - `"null"` → `null` (when schema expects null)
+ * - `"{...}"` → `{...}` (when schema expects object)
+ * - `"[...]"` → `[...]` (when schema expects array)
+ *
+ * Use this when your SDK provides already-parsed objects but values may have
+ * wrong types. For raw JSON strings, use {@link parse} instead.
+ *
+ * For repeated coercion, use {@link createCoerce} to avoid regenerating the
+ * schema each time.
+ *
+ * Type validation is NOT performed—use {@link ILlmFunction.validate} or
+ * `typia.validate()` for that.
+ *
+ * Related functions:
+ *
+ * - {@link createCoerce} — Create reusable coercer function
+ * - {@link parse} — Parse and coerce raw JSON strings
+ * - {@link parameters} — Generate parameters schema from type
+ *
+ * @template Parameters Target parameters type (object with static properties)
+ * @template Config LLM schema configuration
+ * @param input Parsed arguments object from LLM (with potentially wrong types)
+ * @returns Coerced arguments with corrected types
+ */
+export function coerce<
+  Parameters extends Record<string, any>,
+  Config extends Partial<ILlmSchema.IConfig> = {},
+>(input: Parameters): Parameters;
+
+/** @internal */
+export function coerce(): never {
+  NoTransformConfigurationError("llm.coerce");
+}
+
+/**
+ * Create reusable LLM JSON parser with type coercion.
+ *
+ * @danger You must configure the generic argument `Parameters`
+ */
+export function createParse(): never;
+
+/**
+ * Create reusable lenient JSON parser with schema-based type coercion.
+ *
+ * Returns a parser function that handles incomplete or 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 based on the `Parameters` schema:
+ *
+ * - `"42"` → `42` (when schema expects number)
+ * - `"true"` → `true` (when schema expects boolean)
+ * - `"null"` → `null` (when schema expects null)
+ * - `"{...}"` → `{...}` (when schema expects object)
+ * - `"[...]"` → `[...]` (when schema expects array)
+ *
+ * Use this instead of {@link parse} when parsing multiple inputs to avoid
+ * regenerating the schema each time.
+ *
+ * Type validation is NOT performed—use {@link ILlmFunction.validate} or
+ * `typia.validate()` for that.
+ *
+ * Related functions:
+ *
+ * - {@link parse} — One-shot parsing (regenerates schema each call)
+ * - {@link createCoerce} — Create reusable coercer function
+ * - {@link parameters} — Generate parameters schema from type
+ *
+ * @template Parameters Target parameters type (object with static properties)
+ * @template Config LLM schema configuration
+ * @returns Reusable parser function
+ */
+export function createParse<
+  Parameters extends Record<string, any>,
+  Config extends Partial<ILlmSchema.IConfig> = {},
+>(): (input: string) => IJsonParseResult<Parameters>;
+
+/** @internal */
+export function createParse(): never {
+  NoTransformConfigurationError("llm.createParse");
+}
+
+/**
+ * Create reusable LLM arguments coercer.
+ *
+ * @danger You must configure the generic argument `Parameters`
+ */
+export function createCoerce(): never;
+
+/**
+ * Create reusable coercer for LLM arguments.
+ *
+ * Returns a coercer function that fixes incorrect types commonly returned by
+ * LLMs (e.g., numbers as strings). Coerces values based on the `Parameters`
+ * schema:
+ *
+ * - `"42"` → `42` (when schema expects number)
+ * - `"true"` → `true` (when schema expects boolean)
+ * - `"null"` → `null` (when schema expects null)
+ * - `"{...}"` → `{...}` (when schema expects object)
+ * - `"[...]"` → `[...]` (when schema expects array)
+ *
+ * Use this instead of {@link coerce} when coercing multiple inputs to avoid
+ * regenerating the schema each time.
+ *
+ * Type validation is NOT performed—use {@link ILlmFunction.validate} or
+ * `typia.validate()` for that.
+ *
+ * Related functions:
+ *
+ * - {@link coerce} — One-shot coercion (regenerates schema each call)
+ * - {@link createParse} — Create reusable parser function
+ * - {@link parameters} — Generate parameters schema from type
+ *
+ * @template Parameters Target parameters type (object with static properties)
+ * @template Config LLM schema configuration
+ * @returns Reusable coercer function
+ */
+export function createCoerce<
+  Parameters extends Record<string, any>,
+  Config extends Partial<ILlmSchema.IConfig> = {},
+>(): (input: Parameters) => Parameters;
+
+/** @internal */
+export function createCoerce(): never {
+  NoTransformConfigurationError("llm.createCoerce");
+}

package/src/re-exports.ts

@@ -1,33 +1,34 @@
-export {
-  // validate
-  AssertionGuard,
-  IJsonParseResult,
-  IValidation,
-  IRandomGenerator,
-  // json
-  OpenApi,
-  IJsonSchemaCollection,
-  IJsonSchemaUnit,
-  // llm
-  ILlmController,
-  ILlmApplication,
-  ILlmFunction,
-  ILlmSchema,
-  // reflect
-  IMetadataSchema,
-  IMetadataSchemaCollection,
-  IMetadataSchemaUnit,
-  IMetadataComponents,
-  IMetadataTypeTag,
-  IJsDocTagInfo,
-  // typings
-  Primitive,
-  Resolved,
-  CamelCase,
-  PascalCase,
-  SnakeCase,
-  // http
-  IReadableURLSearchParams,
-  // namespaces
-  tags,
-} from "@typia/interface";
+export {
+  // validate
+  AssertionGuard,
+  IJsonParseResult,
+  IValidation,
+  IRandomGenerator,
+  // json
+  OpenApi,
+  IJsonSchemaCollection,
+  IJsonSchemaUnit,
+  // llm
+  ILlmController,
+  ILlmApplication,
+  ILlmFunction,
+  ILlmStructuredOutput,
+  ILlmSchema,
+  // reflect
+  IMetadataSchema,
+  IMetadataSchemaCollection,
+  IMetadataSchemaUnit,
+  IMetadataComponents,
+  IMetadataTypeTag,
+  IJsDocTagInfo,
+  // typings
+  Primitive,
+  Resolved,
+  CamelCase,
+  PascalCase,
+  SnakeCase,
+  // http
+  IReadableURLSearchParams,
+  // namespaces
+  tags,
+} from "@typia/interface";