typia 14.0.5 → 15.0.0

package/lib/internal/_createLlmEvaluation.mjs

@@ -0,0 +1,382 @@
+import { _accessExpressionAsString } from "./_accessExpressionAsString.mjs";
+//#region src/internal/_createLlmEvaluation.ts
+/**
+* Creates the `ILlmEvaluation` of `typia.llm.evaluation<T>()` from its plan.
+*
+* Both the question map and the decoder derive their keys from here, so the
+* readable path encoding has a single owner.
+*
+* @internal
+*/
+const _createLlmEvaluation = (plan) => {
+	const questions = {};
+	for (const leaf of plan) if (leaf.kind === "set") for (const member of leaf.members) assign(questions, key([...leaf.path, member.value]), {
+		type: "boolean",
+		instructions: setInstructions(leaf, member)
+	});
+	else assign(questions, key(leaf.path), question(leaf));
+	return {
+		questions,
+		decode: (answers, rounding) => decode(plan, answers, rounding)
+	};
+};
+/**
+* Encodes a property path as a question key, like `refund.requested`.
+*
+* Every segment after the first uses typia's accessor notation, so the key is
+* the validation path without its `$input` root. The first segment is quoted
+* when it is not an identifier, and always when it is `__proto__`, so no key
+* can collide with another or reach an object's prototype.
+*/
+const key = (path) => {
+	const head = path[0];
+	const postfix = _accessExpressionAsString(head);
+	return (head === "__proto__" ? `[${JSON.stringify(head)}]` : postfix.startsWith(".") ? head : postfix) + path.slice(1).map(_accessExpressionAsString).join("");
+};
+const question = (leaf) => {
+	if (leaf.kind === "boolean") return {
+		type: "boolean",
+		instructions: leaf.instructions
+	};
+	else if (leaf.kind === "choice") {
+		const criteria = {};
+		for (const option of leaf.options) assign(criteria, option.value, option.description ?? null);
+		return {
+			type: "choice",
+			instructions: leaf.instructions,
+			criteria
+		};
+	}
+	return {
+		type: "score",
+		instructions: leaf.instructions,
+		criteria: leaf.levels.map((level) => level.description ?? String(level.value))
+	};
+};
+const setInstructions = (leaf, member) => [
+	leaf.instructions,
+	"",
+	`Does the option ${JSON.stringify(member.value)} apply?`,
+	...member.description !== void 0 ? [member.description] : []
+].join("\n");
+const decode = (plan, answers, rounding) => {
+	const precision = (() => {
+		try {
+			return readPrecision(rounding);
+		} catch {
+			return null;
+		}
+	})();
+	if (precision === null) return {
+		success: false,
+		data: answers,
+		errors: [{
+			path: "$input",
+			expected: "rounding decimals in [0, 15]",
+			value: rounding,
+			description: "Evaluation rounding decimals must be integers between 0 and 15."
+		}]
+	};
+	const map = object(answers);
+	if (map === null) return {
+		success: false,
+		data: answers,
+		errors: [{
+			path: "$input",
+			expected: "Record<string, ILlmEvaluation answer>",
+			value: answers
+		}]
+	};
+	const errors = [];
+	const expected = /* @__PURE__ */ new Set();
+	const output = {};
+	const read = (id) => {
+		expected.add(id);
+		try {
+			return Object.prototype.hasOwnProperty.call(map, id) ? map[id] : void 0;
+		} catch {
+			return;
+		}
+	};
+	for (const leaf of plan) {
+		const path = accessor(leaf.path);
+		if (leaf.kind === "set") {
+			const values = [];
+			for (const member of leaf.members) {
+				const memberPath = [path, _accessExpressionAsString(member.value)].join("");
+				const answer = read(key([...leaf.path, member.value]));
+				const probability = inspect(memberPath, answer, errors, () => booleanProbability(answer, memberPath, errors));
+				if (probability !== null && probability >= member.threshold) values.push(member.value);
+			}
+			place(output, leaf.path, values);
+			continue;
+		}
+		const answer = read(key(leaf.path));
+		if (leaf.kind === "boolean") {
+			const probability = inspect(path, answer, errors, () => booleanProbability(answer, path, errors));
+			if (probability !== null) place(output, leaf.path, probability >= leaf.threshold);
+		} else if (leaf.kind === "choice") {
+			const value = inspect(path, answer, errors, () => choice(leaf, answer, path, errors, precision));
+			if (value !== null) place(output, leaf.path, value);
+		} else {
+			const value = inspect(path, answer, errors, () => score(leaf, answer, path, errors, precision));
+			if (value !== null) place(output, leaf.path, value);
+		}
+	}
+	let received;
+	try {
+		received = Object.keys(map);
+	} catch {
+		errors.push({
+			path: "$input",
+			expected: "readable evaluation answer map",
+			value: answers,
+			description: "Evaluation answer keys could not be inspected."
+		});
+		received = [];
+	}
+	for (const id of received) if (expected.has(id) === false) try {
+		errors.push({
+			path: `$input${_accessExpressionAsString(id)}`,
+			expected: "undefined",
+			value: map[id],
+			description: "The answer does not belong to any question."
+		});
+	} catch {
+		errors.push({
+			path: `$input${_accessExpressionAsString(id)}`,
+			expected: "readable evaluation answer",
+			value: void 0,
+			description: "The extra answer could not be inspected."
+		});
+	}
+	return errors.length === 0 ? {
+		success: true,
+		data: output
+	} : {
+		success: false,
+		data: answers,
+		errors
+	};
+};
+/** Contain exceptions from getters and proxies at the decision path. */
+const inspect = (path, answer, errors, read) => {
+	try {
+		return read();
+	} catch {
+		errors.push({
+			path,
+			expected: "readable evaluation answer",
+			value: answer,
+			description: "The answer could not be inspected."
+		});
+		return null;
+	}
+};
+const booleanProbability = (answer, path, errors) => {
+	const record = object(answer);
+	const type = record?.type;
+	const probability = record === null ? void 0 : type === "boolean" ? record.probability : type === "noul" ? record.noul : void 0;
+	if (isProbability(probability)) return probability;
+	errors.push({
+		path,
+		expected: "{ type: \"boolean\"; probability: number } | { type: \"noul\"; noul: number }",
+		value: answer,
+		description: record === null ? "Missing boolean answer." : type !== "boolean" && type !== "noul" ? `Answer type must be "boolean" or "noul", but got ${label(type)}.` : "Boolean answer needs a probability in [0, 1]."
+	});
+	return null;
+};
+const choice = (leaf, answer, path, errors, precision) => {
+	const expected = `{ type: "choice"; choice: ${leaf.options.map((option) => JSON.stringify(option.value)).join(" | ")}; probabilities?: Record<string, number> }`;
+	const record = object(answer);
+	const type = record?.type;
+	const selected = type === "choice" ? record?.choice : void 0;
+	const option = record !== null && type === "choice" ? leaf.options.find((o) => o.value === selected) : void 0;
+	if (record === null || option === void 0) {
+		errors.push({
+			path,
+			expected,
+			value: answer,
+			description: record === null ? "Missing choice answer." : type !== "choice" ? `Answer type must be "choice", but got ${label(type)}.` : "Choice answer must select one of the declared options."
+		});
+		return null;
+	}
+	const probabilities = distribution(record.probabilities, leaf.options.map((o) => o.value), precision.probability);
+	if (probabilities === null) {
+		errors.push({
+			path,
+			expected,
+			value: answer,
+			description: "Choice probabilities must contain every declared option exactly once, use numbers in [0, 1], and sum to 1."
+		});
+		return null;
+	}
+	if (probabilities !== void 0) {
+		const selected = own(probabilities, option.value);
+		if (Object.values(probabilities).some((probability) => probability > selected + PROBABILITY_TOLERANCE)) {
+			errors.push({
+				path,
+				expected,
+				value: answer,
+				description: "Choice answer must select an option with maximum probability."
+			});
+			return null;
+		}
+	}
+	return accept(option, option.value, own(probabilities, option.value), path, answer, expected, errors) ? option.value : null;
+};
+const score = (leaf, answer, path, errors, precision) => {
+	const last = leaf.levels.length - 1;
+	const expected = `{ type: "score"; score: number; probabilities?: Record<string, number> }`;
+	const record = object(answer);
+	const type = record?.type;
+	const scored = type === "score" ? record?.score : void 0;
+	if (record === null || type !== "score" || typeof scored !== "number" || Number.isFinite(scored) === false || scored < 0 || scored > last) {
+		errors.push({
+			path,
+			expected,
+			value: answer,
+			description: record === null ? "Missing score answer." : type !== "score" ? `Answer type must be "score", but got ${label(type)}.` : `Score answer needs a score in [0, ${last}].`
+		});
+		return null;
+	}
+	const probabilities = distribution(record.probabilities, leaf.levels.map((_, i) => String(i)), precision.probability);
+	if (probabilities === null) {
+		errors.push({
+			path,
+			expected,
+			value: answer,
+			description: "Score probabilities must contain every level index exactly once, use numbers in [0, 1], and sum to 1."
+		});
+		return null;
+	}
+	if (probabilities !== void 0) {
+		const mean = leaf.levels.reduce((total, _, index) => total + index * own(probabilities, String(index)), 0);
+		const meanRoundingError = leaf.levels.reduce((total, _, index) => total + index * precision.probability, 0);
+		if (Math.abs(mean - scored) > PROBABILITY_TOLERANCE + meanRoundingError + precision.score) {
+			errors.push({
+				path,
+				expected,
+				value: answer,
+				description: "Score must equal the probability-weighted mean of its distribution."
+			});
+			return null;
+		}
+	}
+	let index = Math.round(scored);
+	if (probabilities !== void 0 && Object.keys(probabilities).length !== 0) {
+		index = -1;
+		leaf.levels.forEach((_, i) => {
+			const p = own(probabilities, String(i));
+			if (p !== void 0 && (index === -1 || p > own(probabilities, String(index)))) index = i;
+		});
+	}
+	const level = leaf.levels[index];
+	return accept(level, level.value, own(probabilities, String(index)), path, answer, expected, errors) ? level.value : null;
+};
+/** Enforces the acceptance minimum of the selected member, if any. */
+const accept = (member, value, probability, path, answer, expected, errors) => {
+	if (member.minimum === void 0) return true;
+	if (probability === void 0) {
+		errors.push({
+			path,
+			expected,
+			value: answer,
+			description: `${JSON.stringify(value)} requires probability >= ${member.minimum}, but the answer has no probability for it.`
+		});
+		return false;
+	}
+	if (probability < member.minimum) {
+		errors.push({
+			path,
+			expected,
+			value: answer,
+			description: `${JSON.stringify(value)} has probability ${probability} < ${member.minimum}.`
+		});
+		return false;
+	}
+	return true;
+};
+/**
+* Reads optional `probabilities`: `undefined` when absent, `null` when
+* malformed.
+*/
+const distribution = (input, keys, roundingError) => {
+	if (input === void 0) return void 0;
+	const record = object(input);
+	if (record === null) return null;
+	if (Object.keys(record).length !== keys.length) return null;
+	const output = {};
+	for (const key of keys) {
+		if (Object.prototype.hasOwnProperty.call(record, key) === false) return null;
+		const probability = record[key];
+		if (isProbability(probability) === false) return null;
+		assign(output, key, probability);
+	}
+	if (Math.abs(Object.values(output).reduce((sum, probability) => sum + probability, 0) - 1) > PROBABILITY_TOLERANCE + keys.length * roundingError) return null;
+	return output;
+};
+/** AI SDK's absolute tolerance for probability sums and derived values. */
+const PROBABILITY_TOLERANCE = 1e-6;
+/** AI SDK's declared decimal-precision rule, without an AI SDK dependency. */
+const readPrecision = (rounding) => {
+	if (rounding === void 0) return {
+		probability: 0,
+		score: 0
+	};
+	if (typeof rounding !== "object" || rounding === null || Array.isArray(rounding)) return null;
+	const record = rounding;
+	const decimalError = (value) => value === void 0 ? 0 : typeof value === "number" && Number.isInteger(value) && value >= 0 && value <= 15 ? .5 * 10 ** -value : null;
+	const probability = decimalError(record.probabilityDecimals);
+	const score = decimalError(record.scoreDecimals);
+	return probability === null || score === null ? null : {
+		probability,
+		score
+	};
+};
+/**
+* Renders an untrusted answer `type` for a message; unlike `JSON.stringify`, it
+* never throws on a bigint or circular value.
+*/
+const label = (value) => typeof value === "string" ? JSON.stringify(value) : typeof value;
+const accessor = (path) => "$input" + path.map(_accessExpressionAsString).join("");
+/** Match AI SDK's JSON-record boundary, including null-prototype dictionaries. */
+const object = (input) => {
+	if (typeof input !== "object" || input === null) return null;
+	try {
+		if (Array.isArray(input)) return null;
+		const prototype = Object.getPrototypeOf(input);
+		return prototype === Object.prototype || prototype === null ? input : null;
+	} catch {
+		return null;
+	}
+};
+/**
+* Reads an own probability, so an option named like an `Object.prototype`
+* member (`constructor`, `toString`, ...) never inherits a value.
+*/
+const own = (probabilities, key) => probabilities !== void 0 && Object.prototype.hasOwnProperty.call(probabilities, key) ? probabilities[key] : void 0;
+const isProbability = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 1;
+/** Writes the leaf value, creating the intermediate objects of its path. */
+const place = (output, path, value) => {
+	let target = output;
+	path.slice(0, -1).forEach((name) => {
+		if (Object.prototype.hasOwnProperty.call(target, name) === false) assign(target, name, {});
+		target = target[name];
+	});
+	assign(target, path[path.length - 1], value);
+};
+/** Own-property assignment that cannot reach the prototype via `__proto__`. */
+const assign = (target, name, value) => {
+	if (name === "__proto__") Object.defineProperty(target, name, {
+		value,
+		enumerable: true,
+		writable: true,
+		configurable: true
+	});
+	else target[name] = value;
+};
+//#endregion
+export { _createLlmEvaluation };
+
+//# sourceMappingURL=_createLlmEvaluation.mjs.map

package/lib/internal/_createLlmEvaluation.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"_createLlmEvaluation.mjs","names":[],"sources":["../../src/internal/_createLlmEvaluation.ts"],"sourcesContent":["import { ILlmEvaluation, IValidation } from \"@typia/interface\";\n\nimport { _accessExpressionAsString } from \"./_accessExpressionAsString\";\n\n/**\n * Compile-time plan of `typia.llm.evaluation<T>()`, one entry per decision leaf\n * of `T`.\n *\n * @internal\n */\nexport type _ILlmEvaluationPlan =\n  | _ILlmEvaluationPlan.IBoolean\n  | _ILlmEvaluationPlan.IChoice\n  | _ILlmEvaluationPlan.IScore\n  | _ILlmEvaluationPlan.ISet;\n\n/** @internal */\nexport namespace _ILlmEvaluationPlan {\n  interface IBase {\n    /** Property names from the root of `T` to the leaf. */\n    path: string[];\n    instructions: string;\n  }\n  export interface IBoolean extends IBase {\n    kind: \"boolean\";\n    threshold: number;\n  }\n  export interface IChoice extends IBase {\n    kind: \"choice\";\n    options: IMember<string>[];\n  }\n  export interface IScore extends IBase {\n    kind: \"score\";\n    /** Sorted in ascending value order; level `i` is `levels[i]`. */\n    levels: IMember<number>[];\n  }\n  export interface ISet extends IBase {\n    kind: \"set\";\n    members: ISetMember[];\n  }\n  export interface IMember<Value extends string | number> {\n    value: Value;\n    description?: string;\n    /** Acceptance minimum of the member, when it has one. */\n    minimum?: number;\n  }\n  export interface ISetMember {\n    value: string;\n    description?: string;\n    threshold: number;\n  }\n}\n\n/**\n * Creates the `ILlmEvaluation` of `typia.llm.evaluation<T>()` from its plan.\n *\n * Both the question map and the decoder derive their keys from here, so the\n * readable path encoding has a single owner.\n *\n * @internal\n */\nexport const _createLlmEvaluation = <T>(\n  plan: _ILlmEvaluationPlan[],\n): ILlmEvaluation<T> => {\n  const questions: Record<string, ILlmEvaluation.IQuestion> = {};\n  for (const leaf of plan) {\n    if (leaf.kind === \"set\")\n      for (const member of leaf.members)\n        assign(questions, key([...leaf.path, member.value]), {\n          type: \"boolean\",\n          instructions: setInstructions(leaf, member),\n        });\n    else assign(questions, key(leaf.path), question(leaf));\n  }\n  return {\n    questions,\n    decode: (\n      answers: unknown,\n      rounding?: ILlmEvaluation.IRounding,\n    ): IValidation<T> => decode(plan, answers, rounding),\n  };\n};\n\n/* -----------------------------------------------------------\n  QUESTIONS\n----------------------------------------------------------- */\n/**\n * Encodes a property path as a question key, like `refund.requested`.\n *\n * Every segment after the first uses typia's accessor notation, so the key is\n * the validation path without its `$input` root. The first segment is quoted\n * when it is not an identifier, and always when it is `__proto__`, so no key\n * can collide with another or reach an object's prototype.\n */\nconst key = (path: string[]): string => {\n  const head: string = path[0]!;\n  const postfix: string = _accessExpressionAsString(head);\n  const first: string =\n    head === \"__proto__\"\n      ? `[${JSON.stringify(head)}]`\n      : postfix.startsWith(\".\")\n        ? head\n        : postfix;\n  return first + path.slice(1).map(_accessExpressionAsString).join(\"\");\n};\n\nconst question = (\n  leaf:\n    | _ILlmEvaluationPlan.IBoolean\n    | _ILlmEvaluationPlan.IChoice\n    | _ILlmEvaluationPlan.IScore,\n): ILlmEvaluation.IQuestion => {\n  if (leaf.kind === \"boolean\")\n    return { type: \"boolean\", instructions: leaf.instructions };\n  else if (leaf.kind === \"choice\") {\n    const criteria: Record<string, string | null> = {};\n    for (const option of leaf.options)\n      assign(criteria, option.value, option.description ?? null);\n    return { type: \"choice\", instructions: leaf.instructions, criteria };\n  }\n  return {\n    type: \"score\",\n    instructions: leaf.instructions,\n    // the transform rejects fewer than two levels\n    criteria: leaf.levels.map(\n      (level) => level.description ?? String(level.value),\n    ) as [string, string, ...string[]],\n  };\n};\n\nconst setInstructions = (\n  leaf: _ILlmEvaluationPlan.ISet,\n  member: _ILlmEvaluationPlan.ISetMember,\n): string =>\n  [\n    leaf.instructions,\n    \"\",\n    `Does the option ${JSON.stringify(member.value)} apply?`,\n    ...(member.description !== undefined ? [member.description] : []),\n  ].join(\"\\n\");\n\n/* -----------------------------------------------------------\n  VALIDATION\n----------------------------------------------------------- */\nconst decode = <T>(\n  plan: _ILlmEvaluationPlan[],\n  answers: unknown,\n  rounding?: ILlmEvaluation.IRounding,\n): IValidation<T> => {\n  const precision: IPrecision | null = (() => {\n    try {\n      return readPrecision(rounding);\n    } catch {\n      // A trapping rounding object is an invalid declaration.\n      return null;\n    }\n  })();\n  if (precision === null)\n    return {\n      success: false,\n      data: answers,\n      errors: [\n        {\n          path: \"$input\",\n          expected: \"rounding decimals in [0, 15]\",\n          value: rounding,\n          description:\n            \"Evaluation rounding decimals must be integers between 0 and 15.\",\n        },\n      ],\n    };\n  const map: Record<string, unknown> | null = object(answers);\n  if (map === null)\n    return {\n      success: false,\n      data: answers,\n      errors: [\n        {\n          path: \"$input\",\n          expected: \"Record<string, ILlmEvaluation answer>\",\n          value: answers,\n        },\n      ],\n    };\n\n  const errors: IValidation.IError[] = [];\n  const expected: Set<string> = new Set();\n  const output: Record<string, unknown> = {};\n  const read = (id: string): unknown => {\n    expected.add(id);\n    try {\n      return Object.prototype.hasOwnProperty.call(map, id)\n        ? map[id]\n        : undefined;\n    } catch {\n      // The decision reader reports the inaccessible answer on its own path.\n      return undefined;\n    }\n  };\n\n  for (const leaf of plan) {\n    const path: string = accessor(leaf.path);\n    if (leaf.kind === \"set\") {\n      const values: string[] = [];\n      for (const member of leaf.members) {\n        const memberPath: string = [\n          path,\n          _accessExpressionAsString(member.value),\n        ].join(\"\");\n        const answer: unknown = read(key([...leaf.path, member.value]));\n        const probability: number | null = inspect(\n          memberPath,\n          answer,\n          errors,\n          () => booleanProbability(answer, memberPath, errors),\n        );\n        if (probability !== null && probability >= member.threshold)\n          values.push(member.value);\n      }\n      place(output, leaf.path, values);\n      continue;\n    }\n    const answer: unknown = read(key(leaf.path));\n    if (leaf.kind === \"boolean\") {\n      const probability: number | null = inspect(path, answer, errors, () =>\n        booleanProbability(answer, path, errors),\n      );\n      if (probability !== null)\n        place(output, leaf.path, probability >= leaf.threshold);\n    } else if (leaf.kind === \"choice\") {\n      const value: string | null = inspect(path, answer, errors, () =>\n        choice(leaf, answer, path, errors, precision),\n      );\n      if (value !== null) place(output, leaf.path, value);\n    } else {\n      const value: number | null = inspect(path, answer, errors, () =>\n        score(leaf, answer, path, errors, precision),\n      );\n      if (value !== null) place(output, leaf.path, value);\n    }\n  }\n  let received: string[];\n  try {\n    received = Object.keys(map);\n  } catch {\n    errors.push({\n      path: \"$input\",\n      expected: \"readable evaluation answer map\",\n      value: answers,\n      description: \"Evaluation answer keys could not be inspected.\",\n    });\n    received = [];\n  }\n  for (const id of received)\n    if (expected.has(id) === false)\n      try {\n        errors.push({\n          path: `$input${_accessExpressionAsString(id)}`,\n          expected: \"undefined\",\n          value: map[id],\n          description: \"The answer does not belong to any question.\",\n        });\n      } catch {\n        errors.push({\n          path: `$input${_accessExpressionAsString(id)}`,\n          expected: \"readable evaluation answer\",\n          value: undefined,\n          description: \"The extra answer could not be inspected.\",\n        });\n      }\n  return errors.length === 0\n    ? { success: true, data: output as T }\n    : { success: false, data: answers, errors };\n};\n\n/** Contain exceptions from getters and proxies at the decision path. */\nconst inspect = <T>(\n  path: string,\n  answer: unknown,\n  errors: IValidation.IError[],\n  read: () => T,\n): T | null => {\n  try {\n    return read();\n  } catch {\n    errors.push({\n      path,\n      expected: \"readable evaluation answer\",\n      value: answer,\n      description: \"The answer could not be inspected.\",\n    });\n    return null;\n  }\n};\n\nconst booleanProbability = (\n  answer: unknown,\n  path: string,\n  errors: IValidation.IError[],\n): number | null => {\n  const record: Record<string, unknown> | null = object(answer);\n  const type: unknown = record?.type;\n  const probability: unknown =\n    record === null\n      ? undefined\n      : type === \"boolean\"\n        ? record.probability\n        : type === \"noul\"\n          ? record.noul\n          : undefined;\n  if (isProbability(probability)) return probability;\n  errors.push({\n    path,\n    expected:\n      '{ type: \"boolean\"; probability: number } | { type: \"noul\"; noul: number }',\n    value: answer,\n    description:\n      record === null\n        ? \"Missing boolean answer.\"\n        : type !== \"boolean\" && type !== \"noul\"\n          ? `Answer type must be \"boolean\" or \"noul\", but got ${label(type)}.`\n          : \"Boolean answer needs a probability in [0, 1].\",\n  });\n  return null;\n};\n\nconst choice = (\n  leaf: _ILlmEvaluationPlan.IChoice,\n  answer: unknown,\n  path: string,\n  errors: IValidation.IError[],\n  precision: IPrecision,\n): string | null => {\n  const expected: string = `{ type: \"choice\"; choice: ${leaf.options\n    .map((option) => JSON.stringify(option.value))\n    .join(\" | \")}; probabilities?: Record<string, number> }`;\n  const record: Record<string, unknown> | null = object(answer);\n  const type: unknown = record?.type;\n  const selected: unknown = type === \"choice\" ? record?.choice : undefined;\n  const option: _ILlmEvaluationPlan.IMember<string> | undefined =\n    record !== null && type === \"choice\"\n      ? leaf.options.find((o) => o.value === selected)\n      : undefined;\n  if (record === null || option === undefined) {\n    errors.push({\n      path,\n      expected,\n      value: answer,\n      description:\n        record === null\n          ? \"Missing choice answer.\"\n          : type !== \"choice\"\n            ? `Answer type must be \"choice\", but got ${label(type)}.`\n            : \"Choice answer must select one of the declared options.\",\n    });\n    return null;\n  }\n  const probabilities: Record<string, number> | null | undefined = distribution(\n    record.probabilities,\n    leaf.options.map((o) => o.value),\n    precision.probability,\n  );\n  if (probabilities === null) {\n    errors.push({\n      path,\n      expected,\n      value: answer,\n      description:\n        \"Choice probabilities must contain every declared option exactly once, use numbers in [0, 1], and sum to 1.\",\n    });\n    return null;\n  }\n  if (probabilities !== undefined) {\n    const selected: number = own(probabilities, option.value)!;\n    if (\n      Object.values(probabilities).some(\n        (probability) => probability > selected + PROBABILITY_TOLERANCE,\n      )\n    ) {\n      errors.push({\n        path,\n        expected,\n        value: answer,\n        description:\n          \"Choice answer must select an option with maximum probability.\",\n      });\n      return null;\n    }\n  }\n  return accept(\n    option,\n    option.value,\n    own(probabilities, option.value),\n    path,\n    answer,\n    expected,\n    errors,\n  )\n    ? option.value\n    : null;\n};\n\nconst score = (\n  leaf: _ILlmEvaluationPlan.IScore,\n  answer: unknown,\n  path: string,\n  errors: IValidation.IError[],\n  precision: IPrecision,\n): number | null => {\n  const last: number = leaf.levels.length - 1;\n  const expected: string = `{ type: \"score\"; score: number; probabilities?: Record<string, number> }`;\n  const record: Record<string, unknown> | null = object(answer);\n  const type: unknown = record?.type;\n  const scored: unknown = type === \"score\" ? record?.score : undefined;\n  if (\n    record === null ||\n    type !== \"score\" ||\n    typeof scored !== \"number\" ||\n    Number.isFinite(scored) === false ||\n    scored < 0 ||\n    scored > last\n  ) {\n    errors.push({\n      path,\n      expected,\n      value: answer,\n      description:\n        record === null\n          ? \"Missing score answer.\"\n          : type !== \"score\"\n            ? `Answer type must be \"score\", but got ${label(type)}.`\n            : `Score answer needs a score in [0, ${last}].`,\n    });\n    return null;\n  }\n  const probabilities: Record<string, number> | null | undefined = distribution(\n    record.probabilities,\n    leaf.levels.map((_, i) => String(i)),\n    precision.probability,\n  );\n  if (probabilities === null) {\n    errors.push({\n      path,\n      expected,\n      value: answer,\n      description:\n        \"Score probabilities must contain every level index exactly once, use numbers in [0, 1], and sum to 1.\",\n    });\n    return null;\n  }\n  if (probabilities !== undefined) {\n    const mean: number = leaf.levels.reduce(\n      (total, _, index) => total + index * own(probabilities, String(index))!,\n      0,\n    );\n    const meanRoundingError: number = leaf.levels.reduce(\n      (total, _, index) => total + index * precision.probability,\n      0,\n    );\n    if (\n      Math.abs(mean - scored) >\n      PROBABILITY_TOLERANCE + meanRoundingError + precision.score\n    ) {\n      errors.push({\n        path,\n        expected,\n        value: answer,\n        description:\n          \"Score must equal the probability-weighted mean of its distribution.\",\n      });\n      return null;\n    }\n  }\n\n  // the most probable level when a distribution exists, where a tie resolves\n  // to the lower level; otherwise the level nearest to the fractional score,\n  // where a half rounds up\n  let index: number = Math.round(scored);\n  if (probabilities !== undefined && Object.keys(probabilities).length !== 0) {\n    index = -1;\n    leaf.levels.forEach((_, i) => {\n      const p: number | undefined = own(probabilities, String(i));\n      if (\n        p !== undefined &&\n        (index === -1 || p > own(probabilities, String(index))!)\n      )\n        index = i;\n    });\n  }\n  const level: _ILlmEvaluationPlan.IMember<number> = leaf.levels[index]!;\n  return accept(\n    level,\n    level.value,\n    own(probabilities, String(index)),\n    path,\n    answer,\n    expected,\n    errors,\n  )\n    ? level.value\n    : null;\n};\n\n/** Enforces the acceptance minimum of the selected member, if any. */\nconst accept = (\n  member: { minimum?: number },\n  value: string | number,\n  probability: number | undefined,\n  path: string,\n  answer: unknown,\n  expected: string,\n  errors: IValidation.IError[],\n): boolean => {\n  if (member.minimum === undefined) return true;\n  if (probability === undefined) {\n    errors.push({\n      path,\n      expected,\n      value: answer,\n      description: `${JSON.stringify(value)} requires probability >= ${member.minimum}, but the answer has no probability for it.`,\n    });\n    return false;\n  }\n  if (probability < member.minimum) {\n    errors.push({\n      path,\n      expected,\n      value: answer,\n      description: `${JSON.stringify(value)} has probability ${probability} < ${member.minimum}.`,\n    });\n    return false;\n  }\n  return true;\n};\n\n/**\n * Reads optional `probabilities`: `undefined` when absent, `null` when\n * malformed.\n */\nconst distribution = (\n  input: unknown,\n  keys: string[],\n  roundingError: number,\n): Record<string, number> | null | undefined => {\n  if (input === undefined) return undefined;\n  const record: Record<string, unknown> | null = object(input);\n  if (record === null) return null;\n  if (Object.keys(record).length !== keys.length) return null;\n  const output: Record<string, number> = {};\n  for (const key of keys) {\n    if (Object.prototype.hasOwnProperty.call(record, key) === false)\n      return null;\n    const probability: unknown = record[key];\n    if (isProbability(probability) === false) return null;\n    assign(output, key, probability);\n  }\n  if (\n    Math.abs(\n      Object.values(output).reduce((sum, probability) => sum + probability, 0) -\n        1,\n    ) >\n    PROBABILITY_TOLERANCE + keys.length * roundingError\n  )\n    return null;\n  return output;\n};\n\n/** AI SDK's absolute tolerance for probability sums and derived values. */\nconst PROBABILITY_TOLERANCE = 1e-6;\n\ninterface IPrecision {\n  probability: number;\n  score: number;\n}\n\n/** AI SDK's declared decimal-precision rule, without an AI SDK dependency. */\nconst readPrecision = (\n  rounding: ILlmEvaluation.IRounding | undefined,\n): IPrecision | null => {\n  if (rounding === undefined) return { probability: 0, score: 0 };\n  if (\n    typeof rounding !== \"object\" ||\n    rounding === null ||\n    Array.isArray(rounding)\n  )\n    return null;\n  const record: Record<string, unknown> = rounding as Record<string, unknown>;\n  const decimalError = (value: unknown): number | null =>\n    value === undefined\n      ? 0\n      : typeof value === \"number\" &&\n          Number.isInteger(value) &&\n          value >= 0 &&\n          value <= 15\n        ? 0.5 * 10 ** -value\n        : null;\n  const probability: number | null = decimalError(record.probabilityDecimals);\n  const score: number | null = decimalError(record.scoreDecimals);\n  return probability === null || score === null ? null : { probability, score };\n};\n\n/* -----------------------------------------------------------\n  HELPERS\n----------------------------------------------------------- */\n/**\n * Renders an untrusted answer `type` for a message; unlike `JSON.stringify`, it\n * never throws on a bigint or circular value.\n */\nconst label = (value: unknown): string =>\n  typeof value === \"string\" ? JSON.stringify(value) : typeof value;\n\nconst accessor = (path: string[]): string =>\n  \"$input\" + path.map(_accessExpressionAsString).join(\"\");\n\n/** Match AI SDK's JSON-record boundary, including null-prototype dictionaries. */\nconst object = (input: unknown): Record<string, unknown> | null => {\n  if (typeof input !== \"object\" || input === null) return null;\n  try {\n    if (Array.isArray(input)) return null;\n    const prototype: object | null = Object.getPrototypeOf(input);\n    return prototype === Object.prototype || prototype === null\n      ? (input as Record<string, unknown>)\n      : null;\n  } catch {\n    // A revoked or trapping proxy is not a usable answer record.\n    return null;\n  }\n};\n\n/**\n * Reads an own probability, so an option named like an `Object.prototype`\n * member (`constructor`, `toString`, ...) never inherits a value.\n */\nconst own = (\n  probabilities: Record<string, number> | undefined,\n  key: string,\n): number | undefined =>\n  probabilities !== undefined &&\n  Object.prototype.hasOwnProperty.call(probabilities, key)\n    ? probabilities[key]\n    : undefined;\n\nconst isProbability = (value: unknown): value is number =>\n  typeof value === \"number\" &&\n  Number.isFinite(value) &&\n  value >= 0 &&\n  value <= 1;\n\n/** Writes the leaf value, creating the intermediate objects of its path. */\nconst place = (\n  output: Record<string, unknown>,\n  path: string[],\n  value: unknown,\n): void => {\n  let target: Record<string, unknown> = output;\n  path.slice(0, -1).forEach((name) => {\n    if (Object.prototype.hasOwnProperty.call(target, name) === false)\n      assign(target, name, {});\n    target = target[name] as Record<string, unknown>;\n  });\n  assign(target, path[path.length - 1]!, value);\n};\n\n/** Own-property assignment that cannot reach the prototype via `__proto__`. */\nconst assign = (\n  target: Record<string, unknown>,\n  name: string,\n  value: unknown,\n): void => {\n  if (name === \"__proto__\")\n    Object.defineProperty(target, name, {\n      value,\n      enumerable: true,\n      writable: true,\n      configurable: true,\n    });\n  else target[name] = value;\n};\n"],"mappings":"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"}

package/lib/internal/_stringLengthGte.d.ts

@@ -0,0 +1 @@
+export declare const _stringLengthGte: (value: string, length: number) => boolean;

package/lib/internal/_stringLengthGte.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._stringLengthGte = void 0;
+const _stringLengthGte = (value, length) => {
+    let count = 0;
+    if (length <= count)
+        return true;
+    for (const _ch of value)
+        if (length <= ++count)
+            return true;
+    return false;
+};
+exports._stringLengthGte = _stringLengthGte;
+//# sourceMappingURL=_stringLengthGte.js.map

package/lib/internal/_stringLengthGte.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_stringLengthGte.js","sourceRoot":"","sources":["../../src/internal/_stringLengthGte.ts"],"names":[],"mappings":";;;AAAO,MAAM,gBAAgB,GAAG,CAAC,KAAa,EAAE,MAAc,EAAW,EAAE;IACzE,IAAI,KAAK,GAAW,CAAC,CAAC;IACtB,IAAI,MAAM,IAAI,KAAK;QAAE,OAAO,IAAI,CAAC;IACjC,KAAK,MAAM,GAAG,IAAI,KAAK;QAAE,IAAI,MAAM,IAAI,EAAE,KAAK;YAAE,OAAO,IAAI,CAAC;IAC5D,OAAO,KAAK,CAAC;AACf,CAAC,CAAC;AALW,QAAA,gBAAgB,GAAhB,gBAAgB,CAK3B"}

package/lib/internal/_stringLengthGte.mjs

@@ -0,0 +1,11 @@
+//#region src/internal/_stringLengthGte.ts
+const _stringLengthGte = (value, length) => {
+	let count = 0;
+	if (length <= count) return true;
+	for (const _ch of value) if (length <= ++count) return true;
+	return false;
+};
+//#endregion
+export { _stringLengthGte };
+
+//# sourceMappingURL=_stringLengthGte.mjs.map

package/lib/internal/_stringLengthGte.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"_stringLengthGte.mjs","names":[],"sources":["../../src/internal/_stringLengthGte.ts"],"sourcesContent":["export const _stringLengthGte = (value: string, length: number): boolean => {\n  let count: number = 0;\n  if (length <= count) return true;\n  for (const _ch of value) if (length <= ++count) return true;\n  return false;\n};\n"],"mappings":";AAAA,MAAa,oBAAoB,OAAe,WAA4B;CAC1E,IAAI,QAAgB;CACpB,IAAI,UAAU,OAAO,OAAO;CAC5B,KAAK,MAAM,OAAO,OAAO,IAAI,UAAU,EAAE,OAAO,OAAO;CACvD,OAAO;AACT"}

package/lib/internal/_stringLengthLte.d.ts

@@ -0,0 +1 @@
+export declare const _stringLengthLte: (value: string, length: number) => boolean;

package/lib/internal/_stringLengthLte.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._stringLengthLte = void 0;
+const _stringLengthLte = (value, length) => {
+    let count = 0;
+    if (!(count <= length))
+        return false;
+    for (const _ch of value)
+        if (!(++count <= length))
+            return false;
+    return true;
+};
+exports._stringLengthLte = _stringLengthLte;
+//# sourceMappingURL=_stringLengthLte.js.map

package/lib/internal/_stringLengthLte.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_stringLengthLte.js","sourceRoot":"","sources":["../../src/internal/_stringLengthLte.ts"],"names":[],"mappings":";;;AAAO,MAAM,gBAAgB,GAAG,CAAC,KAAa,EAAE,MAAc,EAAW,EAAE;IACzE,IAAI,KAAK,GAAW,CAAC,CAAC;IACtB,IAAI,CAAC,CAAC,KAAK,IAAI,MAAM,CAAC;QAAE,OAAO,KAAK,CAAC;IACrC,KAAK,MAAM,GAAG,IAAI,KAAK;QAAE,IAAI,CAAC,CAAC,EAAE,KAAK,IAAI,MAAM,CAAC;YAAE,OAAO,KAAK,CAAC;IAChE,OAAO,IAAI,CAAC;AACd,CAAC,CAAC;AALW,QAAA,gBAAgB,GAAhB,gBAAgB,CAK3B"}

package/lib/internal/_stringLengthLte.mjs

@@ -0,0 +1,11 @@
+//#region src/internal/_stringLengthLte.ts
+const _stringLengthLte = (value, length) => {
+	let count = 0;
+	if (!(count <= length)) return false;
+	for (const _ch of value) if (!(++count <= length)) return false;
+	return true;
+};
+//#endregion
+export { _stringLengthLte };
+
+//# sourceMappingURL=_stringLengthLte.mjs.map

package/lib/internal/_stringLengthLte.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"_stringLengthLte.mjs","names":[],"sources":["../../src/internal/_stringLengthLte.ts"],"sourcesContent":["export const _stringLengthLte = (value: string, length: number): boolean => {\n  let count: number = 0;\n  if (!(count <= length)) return false;\n  for (const _ch of value) if (!(++count <= length)) return false;\n  return true;\n};\n"],"mappings":";AAAA,MAAa,oBAAoB,OAAe,WAA4B;CAC1E,IAAI,QAAgB;CACpB,IAAI,EAAE,SAAS,SAAS,OAAO;CAC/B,KAAK,MAAM,OAAO,OAAO,IAAI,EAAE,EAAE,SAAS,SAAS,OAAO;CAC1D,OAAO;AACT"}

package/lib/llm.d.ts

@@ -1,4 +1,4 @@
-import { IJsonParseResult, ILlmApplication, ILlmController, ILlmSchema, ILlmStructuredOutput } from "@typia/interface";
+import { IJsonParseResult, ILlmApplication, ILlmController, ILlmEvaluation, ILlmSchema, ILlmStructuredOutput } from "@typia/interface";
 /**
  * Creates LLM function calling controller.
  *
@@ -141,6 +141,59 @@ export declare function structuredOutput<T extends Record<string, any>, Config e
      */
     equals: boolean;
 }> = {}>(): ILlmStructuredOutput<T>;
+/**
+ * Creates LLM evaluation questions.
+ *
+ * @danger You must configure the generic argument `T`
+ */
+export declare function evaluation(): never;
+/**
+ * Creates LLM evaluation questions from TypeScript object type.
+ *
+ * Generates {@link ILlmEvaluation} for evaluation models, which answer typed
+ * questions about a shared state with probabilities instead of generating text:
+ * TypeSafe's Jev natively, and OpenAI, Anthropic, and Google through Vercel AI
+ * SDK's `experimental_evaluate()`.
+ *
+ * Every leaf property of `T` becomes one question, and its JSDoc description
+ * becomes the question text:
+ *
+ * - `boolean` → boolean question
+ * - String enum or string literal union → choice question
+ * - Numeric enum or numeric literal union → score question
+ * - Array of a string literal union or string enum → one boolean question per
+ *   member
+ * - Nested object → flattened, one question per leaf
+ *
+ * Types an evaluation model cannot answer, such as `string`, `number`, optional
+ * properties, or a leaf without a JSDoc description, are compile errors. Use
+ * `tags.Probability<N>` or `@probability N` to set decision thresholds and
+ * acceptance minimums. Once one choice, score, or set member declares a
+ * requirement, every member must declare one or inherit the property's
+ * `@probability` default. A nested object's own JSDoc description is not sent
+ * to the model; only the leaves' descriptions become question text. Other
+ * validation refinements that the answer decoder cannot enforce are compile
+ * errors.
+ *
+ * This feature is experimental. It follows Vercel AI SDK's evaluation model
+ * specification, which is itself experimental and may change in patch
+ * releases.
+ *
+ * Workflow:
+ *
+ * 1. Pass {@link ILlmEvaluation.questions} to the evaluation model
+ * 2. Receive the answer map keyed by the same question IDs
+ * 3. Use {@link ILlmEvaluation.decode} to fold the answers back into `T`; pass the
+ *    model's declared rounding precision when available
+ *
+ * Related functions:
+ *
+ * - {@link structuredOutput} — Structured output generated as text by an LLM
+ *
+ * @template T Target decision type (object with static properties)
+ * @returns LLM evaluation questions with a checked answer decoder
+ */
+export declare function evaluation<T extends Record<string, any>>(): ILlmEvaluation<T>;
 /**
  * Creates LLM parameters schema.
  *

package/lib/llm.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.controller = controller;
 exports.application = application;
 exports.structuredOutput = structuredOutput;
+exports.evaluation = evaluation;
 exports.parameters = parameters;
 exports.schema = schema;
 exports.parse = parse;
@@ -23,6 +24,10 @@ function structuredOutput() {
     (0, NoTransformConfigurationError_1.NoTransformConfigurationError)("llm.structuredOutput");
 }
 /** @internal */
+function evaluation() {
+    (0, NoTransformConfigurationError_1.NoTransformConfigurationError)("llm.evaluation");
+}
+/** @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":";;;;;;;;;;;AAQA,gGAA6F;AAmE7F,gBAAgB;AAChB,oBAA2B,GAAG,KAAY;IACxC,IAAA,6DAA6B,EAAC,gBAAgB,CAAC,CAAC;AAClD,CAAC;AA0DD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,iBAAiB,CAAC,CAAC;AACnD,CAAC;AA2DD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,sBAAsB,CAAC,CAAC;AACxD,CAAC;AAuCD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,gBAAgB,CAAC,CAAC;AAClD,CAAC;AAsCD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,YAAY,CAAC,CAAC;AAC9C,CAAC;AAoDD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,WAAW,CAAC,CAAC;AAC7C,CAAC;AAuCD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,YAAY,CAAC,CAAC;AAC9C,CAAC;AAiDD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,iBAAiB,CAAC,CAAC;AACnD,CAAC;AA2CD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,kBAAkB,CAAC,CAAC;AACpD,CAAC"}
+{"version":3,"file":"llm.js","sourceRoot":"","sources":["../src/llm.ts"],"names":[],"mappings":";;;;;;;;;;;;AASA,gGAA6F;AAmE7F,gBAAgB;AAChB,oBAA2B,GAAG,KAAY;IACxC,IAAA,6DAA6B,EAAC,gBAAgB,CAAC,CAAC;AAClD,CAAC;AA0DD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,iBAAiB,CAAC,CAAC;AACnD,CAAC;AA2DD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,sBAAsB,CAAC,CAAC;AACxD,CAAC;AA4DD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,gBAAgB,CAAC,CAAC;AAClD,CAAC;AAuCD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,gBAAgB,CAAC,CAAC;AAClD,CAAC;AAsCD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,YAAY,CAAC,CAAC;AAC9C,CAAC;AAoDD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,WAAW,CAAC,CAAC;AAC7C,CAAC;AAuCD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,YAAY,CAAC,CAAC;AAC9C,CAAC;AAiDD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,iBAAiB,CAAC,CAAC;AACnD,CAAC;AA2CD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,kBAAkB,CAAC,CAAC;AACpD,CAAC"}

package/lib/llm.mjs

@@ -7,6 +7,7 @@ var llm_exports = /* @__PURE__ */ __exportAll({
 	controller: () => controller,
 	createCoerce: () => createCoerce,
 	createParse: () => createParse,
+	evaluation: () => evaluation,
 	parameters: () => parameters,
 	parse: () => parse,
 	schema: () => schema,
@@ -25,6 +26,10 @@ function structuredOutput() {
 	NoTransformConfigurationError("llm.structuredOutput");
 }
 /** @internal */
+function evaluation() {
+	NoTransformConfigurationError("llm.evaluation");
+}
+/** @internal */
 function parameters() {
 	NoTransformConfigurationError("llm.parameters");
 }
@@ -49,6 +54,6 @@ function createCoerce() {
 	NoTransformConfigurationError("llm.createCoerce");
 }
 //#endregion
-export { application, coerce, controller, createCoerce, createParse, llm_exports, parameters, parse, schema, structuredOutput };
+export { application, coerce, controller, createCoerce, createParse, evaluation, llm_exports, parameters, parse, schema, structuredOutput };
 
 //# sourceMappingURL=llm.mjs.map