feat(website): the harness wording on llm module. (#1800)

* feat(website): the harness wording on llm module.

* fix remove

* do not abuse harness wording much a lot

* fix(website): correct grammar in chat.mdx harness section (#1802)

* Initial plan

* fix(website): correct grammar in chat.mdx harness section

Co-authored-by: samchon <13158709+samchon@users.noreply.github.com>

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: samchon <13158709+samchon@users.noreply.github.com>

* fix: add missing `tags` import in function-calling-harness.md example (#1801)

* Initial plan

* fix: add tags to import in function-calling-harness.md example

Co-authored-by: samchon <13158709+samchon@users.noreply.github.com>

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: samchon <13158709+samchon@users.noreply.github.com>

---------

Co-authored-by: Copilot <198982749+Copilot@users.noreply.github.com>

Author: samchon

README.md

@@ -23,12 +23,12 @@ export namespace json {
   export function assertStringify<T>(input: T): string; // safe and faster
 }
 
-// AI FUNCTION CALLING SCHEMA
+// AI FUNCTION CALLING HARNESS
 export namespace llm {
   // collection of function calling schemas + validators/parsers
   export function application<Class>(): ILlmApplication<Class>;
   export function structuredOutput<P>(): ILlmStructuredOutput;
-  // lenient json parser + type corecion
+  // lenient json parser + type coercion
   export function parse<T>(str: string): T;
 }
 
@@ -47,7 +47,7 @@ export function random<T>(g?: Partial<IRandomGenerator>): T;
 
   - Super-fast Runtime Validators
   - Enhanced JSON schema and serde functions
-  - LLM function calling schema and structured output
+  - LLM function calling harness
   - Protocol Buffer encoder and decoder
   - Random data generator
 
@@ -56,6 +56,7 @@ export function random<T>(g?: Partial<IRandomGenerator>): T;
 > - **Only one line** required, with pure TypeScript type
 > - Runtime validator is **20,000x faster** than `class-validator`
 > - JSON serialization is **200x faster** than `class-transformer`
+> - LLM function calling harness turns **6.75% → 100%** accuracy
 
 ## Transformation
 If you call `typia` function, it would be compiled like below.
@@ -121,7 +122,7 @@ Check out the document in the [website](https://typia.io/docs/):
   - [JSON Schema](https://typia.io/docs/json/schema/)
   - [`stringify()` functions](https://typia.io/docs/json/stringify/)
   - [`parse()` functions](https://typia.io/docs/json/parse/)
-- LLM Function Calling
+- LLM Function Calling Harness
   - [`application()` function](https://typia.io/docs/llm/application/)
   - [`structuredOutput()` function](https://typia.io/docs/llm/structuredOutput/)
   - [`HttpLlm` module](https://typia.io/docs/llm/http/)
@@ -136,6 +137,9 @@ Check out the document in the [website](https://typia.io/docs/):
 ### 🔗 Appendix
 - [API Documents](https://typia.io/api)
 - Utilization Cases
+  - [MCP](https://typia.io/docs/utilization/mcp/)
+  - [Vercel AI SDK](https://typia.io/docs/utilization/vercel/)
+  - [LangChain](https://typia.io/docs/utilization/langchain/)
   - [NestJS](https://typia.io/docs/utilization/nestjs/)
   - [tRPC](https://typia.io/docs/utilization/trpc/)
 - [⇲ Benchmark Result](https://github.com/samchon/typia/tree/master/benchmark/results/11th%20Gen%20Intel(R)%20Core(TM)%20i5-1135G7%20%40%202.40GHz)

website/articles/function-calling-harness.md

@@ -34,4 +34,3 @@ export default {
     href: "https://dev.to/samchon/series/22474",
   },
 } satisfies MetaRecord;
-

website/src/content/docs/_meta.ts

@@ -66,12 +66,12 @@ export namespace json {
   export function assertStringify<T>(input: T): string; // safe and faster
 }
 
-// AI FUNCTION CALLING SCHEMA
+// AI FUNCTION CALLING HARNESS
 export namespace llm {
   // collection of function calling schemas + validators/parsers
   export function application<Class>(): ILlmApplication<Class>;
   export function structuredOutput<P>(): ILlmStructuredOutput;
-  // lenient json parser + type corecion
+  // lenient json parser + type coercion
   export function parse<T>(str: string): T;
 }
 
@@ -90,7 +90,7 @@ export function random<T>(g?: Partial<IRandomGenerator>): T;
 
   - Super-fast Runtime Validators
   - Enhanced JSON functions
-  - LLM function calling schema and structured output
+  - LLM function calling harness
   - Protocol Buffer encoder and decoder
   - Random data generator
 
@@ -105,6 +105,9 @@ export function random<T>(g?: Partial<IRandomGenerator>): T;
   <Alert severity="info">
     JSON serialization is **200x faster** than `class-transformer`
   </Alert>
+  <Alert severity="success">
+    LLM function calling harness turns **6.75% → 100%** accuracy
+  </Alert>
 </Stack>
 
 ## Transformation

website/src/content/docs/index.mdx

@@ -2,7 +2,7 @@ import { MetaRecord } from "nextra";
 
 export default {
   application: "application() function",
-  structuredOutput: "structuredOutput() function",
+  structuredOutput: "structuredOutput()",
   parameters: "parameters() function",
   schema: "schema() function",
   http: "HttpLlm module",

website/src/content/docs/llm/_meta.ts

@@ -62,7 +62,7 @@ export namespace llm {
 
 LLM function calling application schema from a native TypeScript class or interface type.
 
-`typia.llm.application<App>()` is a function composing LLM (Large Language Model) calling application schema from a native TypeScript class or interface type. The function returns an `ILlmApplication` instance, which is a data structure representing a collection of LLM function calling schemas.
+`typia.llm.application<App>()` is a function composing LLM (Large Language Model) calling application schema from a native TypeScript class or interface type. The function returns an `ILlmApplication` instance, which is a data structure representing a collection of LLM function calling schemas — each with built-in `parse()`, `coerce()`, and `validate()` methods.
 
 If you put LLM function schema instances registered in the `ILlmApplication.functions` to the LLM provider like `OpenAI ChatGPT`, the LLM will select a proper function to call with parameter values of the target function in the conversations with the user. This is the "LLM Function Calling".
 
@@ -207,7 +207,17 @@ registerMcpControllers({
   </Tabs.Tab>
 </Tabs>
 
-## Lenient JSON Parsing
+## The Function Calling Harness
+
+The **function calling harness** is typia's three-layer pipeline that turns unreliable LLM output into 100% correct structured data:
+
+1. **Lenient JSON Parsing** — recovers broken JSON (unclosed brackets, trailing commas, markdown wrapping, etc.)
+2. **Type Coercion** — fixes wrong types (`"42"` → `42`, double-stringified objects → objects, etc.)
+3. **Validation Feedback** — pinpoints remaining value errors with inline `// ❌` annotations so the LLM can self-correct and retry
+
+Each layer catches what the previous one didn't. Together they form a deterministic correction loop around the probabilistic LLM.
+
+### Lenient JSON Parsing & Type Coercion
 
 <Tabs items={[
     "Parsing Example",
@@ -266,7 +276,7 @@ Some LLM SDKs (Anthropic, Vercel AI, LangChain, MCP) parse JSON internally and r
 For more details, see [JSON Utilities](./json).
 </Callout>
 
-## Validation Feedback
+### Validation Feedback
 
 <LocalSource
   path="examples/src/llm/application-validate.ts"
@@ -296,15 +306,21 @@ For more details, see [JSON Utilities](./json).
 }
 ```
 
-The LLM reads this feedback and self-corrects on the next turn.
+The LLM reads this feedback and self-corrects on the next turn. Together with lenient parsing and type coercion above, this parse → coerce → validate → feedback → retry cycle completes the harness.
 
-In the [AutoBe](https://github.com/wrtnlabs/autobe) project (AI-powered backend code generator), `qwen3-coder-next` showed only 6.75% raw function calling success rate on compiler AST types. However, with validation feedback, it reached 100%.
+<Callout type="info">
+**In Production**
+
+In the [AutoBe](https://github.com/wrtnlabs/autobe) project (AI-powered backend code generator by [Wrtn Technologies](https://wrtn.io)), `qwen3-coder-next` showed only **6.75%** raw function calling success rate on compiler AST types. With the complete harness, it reached **100%** — across all four tested Qwen models.
+
+AutoBe once shipped a build with the system prompt completely missing. Nobody noticed — output quality was identical. The types were the best prompt; the harness was the best orchestration.
 
 Working on compiler AST means working on any type and any use case.
 
   - [AutoBeDatabase](https://github.com/wrtnlabs/autobe/blob/main/packages/interface/src/database/AutoBeDatabase.ts)
   - [AutoBeOpenApi](https://github.com/wrtnlabs/autobe/blob/main/packages/interface/src/openapi/AutoBeOpenApi.ts)
   - [AutoBeTest](https://github.com/wrtnlabs/autobe/blob/main/packages/interface/src/test/AutoBeTest.ts)
+</Callout>
 
 ```typescript filename="AutoBeTest.IExpression" showLineNumbers
 // Compiler AST may be the hardest type structure possible

website/src/content/docs/llm/application.mdx

@@ -225,15 +225,15 @@ export const correctFunctionCall = (p: {
 }
 ```
 
-Is LLM function calling perfect? 
+Is LLM function calling perfect?
 
-The answer is not, and LLM (Large Language Model) vendors like OpenAI take a lot of type level mistakes when composing the arguments of the target function to call. Even though an LLM function calling schema has defined an `Array<string>` type, LLM often fills it just by a `string` typed value.
+The answer is no, and LLM (Large Language Model) vendors like OpenAI take a lot of type level mistakes when composing the arguments of the target function to call. Even though an LLM function calling schema has defined an `Array<string>` type, LLM often fills it just by a `string` typed value. This is where the **function calling harness** comes in — a deterministic correction loop of schema generation, lenient parsing, type coercion, and validation feedback that turns unreliable LLM output into 100% correct structured data.
 
 Therefore, when developing an LLM function calling agent, the validation feedback process is essentially required. If LLM takes a type level mistake on arguments composition, the agent must feedback the most detailed validation errors, and let the LLM to retry the function calling referencing the validation errors.
 
 About the validation feedback, `@agentica/core` is utilizing [`typia.validate<T>()`](https://typia.io/docs/validators/validate) and [`typia.llm.application<Class>()`](https://typia.io/docs/llm/application/#application) functions. They construct validation logic by analyzing TypeScript source codes and types in the compilation level, so that detailed and accurate than any other validators like below.
 
-Such validation feedback strategy and combination with `typia` runtime validator, `@agentica/core` has achieved the most ideal LLM function calling. In my experience, when using OpenAI's `gpt-4o-mini` model, it tends to construct invalid function calling arguments at the first trial about 50% of the time. By the way, if correct it through validation feedback with `typia`, success rate soars to 99%. And I've never had a failure when trying validation feedback twice.
+Such validation feedback strategy and combination with `typia` runtime validator, `@agentica/core` has achieved the most ideal LLM function calling through the **function calling harness** pattern. In my experience, when using OpenAI's `gpt-4o-mini` model, it tends to construct invalid function calling arguments at the first trial about 50% of the time. By the way, if you correct it through validation feedback with `typia`, success rate soars to 99%. And I've never had a failure when trying validation feedback twice.
 
 For reference, the embedded [`typia.validate<T>()`](/docs/validators/validate) function creates validation logic by analyzing TypeScript source codes and types in the compilation level. Therefore, it is accurate and detailed than any other validator libraries. This is exactly what is needed for function calling, and I can confidentelly say that `typia` is the best library for LLM function calling.
 

website/src/content/docs/llm/chat.mdx

@@ -60,7 +60,7 @@ export namespace HttpLlm {
 
 LLM function calling from OpenAPI documents.
 
-`HttpLlm` is a utility module from `@typia/utils` that converts OpenAPI (Swagger) documents into LLM function calling schemas. While [`typia.llm.application<Class>()`](./application) generates schemas from TypeScript class types at compile time, `HttpLlm` generates them from OpenAPI documents at runtime — making any REST API instantly callable by LLMs.
+`HttpLlm` is a utility module from `@typia/utils` that converts OpenAPI (Swagger) documents into LLM function calling schemas. While [`typia.llm.application<Class>()`](./application) generates schemas from TypeScript class types at compile time, `HttpLlm` generates them from OpenAPI documents at runtime — making any REST API instantly callable by LLMs. Every generated tool includes lenient parsing, type coercion, and validation feedback.
 
 It supports all OpenAPI versions: Swagger v2.0, OpenAPI v3.0, v3.1, and v3.2.
 
@@ -215,7 +215,17 @@ registerMcpControllers({
   </Tabs.Tab>
 </Tabs>
 
-## Validation Feedback
+## The Function Calling Harness
+
+The **function calling harness** is typia's three-layer pipeline that turns unreliable LLM output into 100% correct structured data:
+
+1. **Lenient JSON Parsing** — recovers broken JSON (unclosed brackets, trailing commas, markdown wrapping, etc.)
+2. **Type Coercion** — fixes wrong types (`"42"` → `42`, double-stringified objects → objects, etc.)
+3. **Validation Feedback** — pinpoints remaining value errors with inline `// ❌` annotations so the LLM can self-correct and retry
+
+Each layer catches what the previous one didn't. Together they form a deterministic correction loop around the probabilistic LLM.
+
+### Validation Feedback
 
 When used through [MCP](/docs/llm/mcp), [Vercel AI SDK](/docs/llm/vercel), or [Agentica](/docs/llm/chat), `HttpLlm.controller()` embeds [`typia.validate<T>()`](/docs/validators/validate) in every tool for automatic argument validation. When validation fails, the error is returned as text content with inline `// ❌` comments at each invalid property:
 
@@ -230,7 +240,7 @@ When used through [MCP](/docs/llm/mcp), [Vercel AI SDK](/docs/llm/vercel), or [A
 
 The LLM reads this feedback and self-corrects on the next turn.
 
-In the [AutoBe](https://github.com/wrtnlabs/autobe) project (AI-powered backend code generator), `qwen3-coder-next` showed only 6.75% raw function calling success rate on compiler AST types. However, with validation feedback, it reached 100%.
+In the [AutoBe](https://github.com/wrtnlabs/autobe) project (AI-powered backend code generator by [Wrtn Technologies](https://wrtn.io)), `qwen3-coder-next` showed only **6.75%** raw function calling success rate on compiler AST types. However, with the complete harness, it reached **100%** — across all four tested Qwen models.
 
 Working on compiler AST means working on any type and any use case.
 
@@ -264,7 +274,7 @@ export type IExpression =
   | ... // 30+ expression types total
 ```
 
-## Lenient JSON Parsing
+### Lenient JSON Parsing & Type Coercion
 
 <Tabs items={[
     "Parsing Example",

website/src/content/docs/llm/http.mdx

@@ -51,7 +51,7 @@ export namespace LlmJson {
 
 JSON utilities for LLM function calling.
 
-`LlmJson` is a utility module from `@typia/utils` package, specifically designed for LLM (Large Language Model) function calling scenarios. It handles the common issues that arise when working with LLM responses:
+`LlmJson` is a utility module from `@typia/utils` package, specifically designed for LLM (Large Language Model) function calling scenarios. Together, these utilities form the **function calling harness** — handling every common failure mode of LLM responses:
 
 1. **Validation Feedback**: Format validation errors for LLM auto-correction
 2. **Lenient JSON Parsing**: LLMs often produce incomplete, malformed, or non-standard JSON
@@ -121,7 +121,7 @@ This format is designed for LLM auto-correction. The LLM reads this feedback and
   filename="examples/src/llm/application-parse.ts"
   showLineNumbers />
 
-`LlmJson.parse()` is a lenient JSON parser specifically designed for LLM outputs. It combines two capabilities:
+`LlmJson.parse()` is a lenient JSON parser specifically designed for LLM outputs. It combines two capabilities in a single call:
 
 1. **Lenient JSON parsing**: Handles malformed/incomplete JSON that would fail with `JSON.parse()`
 2. **Type coercion**: Fixes double-stringified values based on the expected schema
@@ -190,7 +190,7 @@ If you omit the `parameters` argument, `LlmJson.parse()` still performs lenient
   filename="examples/src/llm/application-coerce.ts"
   showLineNumbers />
 
-`LlmJson.coerce()` performs type coercion on already-parsed objects. This is the coercion logic from `parse()` extracted for use when you already have a JavaScript object (not a JSON string).
+`LlmJson.coerce()` performs type coercion on already-parsed objects. Use it when an SDK has already parsed the JSON — this is the coercion logic from `parse()` extracted for use when you already have a JavaScript object (not a JSON string).
 
 ### When to Use `coerce()` vs `parse()`
 
@@ -262,7 +262,7 @@ strict({ name: "John", age: 25, extra: "ignored" }); // success: false
 If you have TypeScript types available at compile time, prefer using `typia.validate<T>()` directly. It's faster (AOT-compiled) and provides better error messages. Use `LlmJson.validate()` only when you need runtime schema-based validation.
 </Callout>
 
-## Validation Feedback Loop
+## Validation Feedback Loop (The Complete Harness)
 
 The real power of these utilities is enabling automatic error correction by LLMs:
 
@@ -355,7 +355,7 @@ const main = async (): Promise<void> => {
 };
 ```
 
-This pattern enables LLMs to automatically correct their mistakes by:
+This is the **function calling harness** in action — the same pattern that powers [AutoBe](https://github.com/wrtnlabs/autobe)'s 100% compilation success across all tested LLM models. It enables LLMs to automatically correct their mistakes:
 
 1. Parse LLM response with `func.parse()` (handles malformed JSON + type coercion)
 2. Validate with `func.validate()`

website/src/content/docs/llm/json.mdx

@@ -157,7 +157,17 @@ You can utilize the `typia.llm.parameters<Parameters>()` function to generate st
 
 Just configure output mode as JSON schema, and deliver the `typia.llm.parameters<Parameters>()` function returned value to the LLM provider like OpenAI (ChatGPT). Then, the LLM provider will automatically transform the output conversation into a structured data format of the `Parameters` type.
 
-## Lenient JSON Parsing
+## The Function Calling Harness
+
+The **function calling harness** is typia's three-layer pipeline that turns unreliable LLM output into 100% correct structured data:
+
+1. **Lenient JSON Parsing** — recovers broken JSON (unclosed brackets, trailing commas, markdown wrapping, etc.)
+2. **Type Coercion** — fixes wrong types (`"42"` → `42`, double-stringified objects → objects, etc.)
+3. **Validation Feedback** — pinpoints remaining value errors with inline `// ❌` annotations so the LLM can self-correct and retry
+
+Each layer catches what the previous one didn't. Together they form a deterministic correction loop around the probabilistic LLM.
+
+### Lenient JSON Parsing & Type Coercion
 
 <Tabs items={[
     "Parsing Example",
@@ -216,7 +226,7 @@ Some LLM SDKs (Anthropic, Vercel AI, LangChain, MCP) parse JSON internally and r
 For more details, see [JSON Utilities](./json).
 </Callout>
 
-## Validation Feedback
+### Validation Feedback
 
 <LocalSource
   path="examples/src/llm/parameters-validate.ts"
@@ -241,7 +251,7 @@ Use [`typia.validate<T>()`](/docs/validators/validate) for validation feedback o
 
 The LLM reads this feedback and self-corrects on the next turn.
 
-In the [AutoBe](https://github.com/wrtnlabs/autobe) project (AI-powered backend code generator), `qwen3-coder-next` showed only 6.75% raw function calling success rate on compiler AST types. However, with validation feedback, it reached 100%.
+In the [AutoBe](https://github.com/wrtnlabs/autobe) project (AI-powered backend code generator by [Wrtn Technologies](https://wrtn.io)), `qwen3-coder-next` showed only **6.75%** raw function calling success rate on compiler AST types. However, with the complete harness, it reached **100%** — across all four tested Qwen models.
 
 Working on compiler AST means working on any type and any use case.