@nhtio/adk 1.20260604.0 → 1.20260607.0

package/batteries/tools/datetime_extended.mjs

@@ -1,5 +1,5 @@
-import { t as Tool } from "../../tool-CRZSUcdP.mjs";
-import "../../common-lMrnzoyn.mjs";
+import { t as Tool } from "../../tool-CMhaDRNd.mjs";
+import "../../common-BT0nfCi9.mjs";
 import { validator } from "@nhtio/validation";
 import { DateTime, IANAZone } from "luxon";
 import * as chrono from "chrono-node";

package/batteries/tools/datetime_math.cjs

@@ -1,7 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 require("../../chunk-Ble4zEEl.js");
-const require_tool = require("../../tool-CX9vNHAw.js");
-require("../../common-D_e5zYsG.js");
+const require_tool = require("../../tool-CVyZkFC7.js");
+require("../../common-Cj8TaQ9U.js");
 let _nhtio_validation = require("@nhtio/validation");
 let luxon = require("luxon");
 //#region src/batteries/tools/datetime_math/index.ts

package/batteries/tools/datetime_math.mjs

@@ -1,5 +1,5 @@
-import { t as Tool } from "../../tool-CRZSUcdP.mjs";
-import "../../common-lMrnzoyn.mjs";
+import { t as Tool } from "../../tool-CMhaDRNd.mjs";
+import "../../common-BT0nfCi9.mjs";
 import { validator } from "@nhtio/validation";
 import { DateTime, Duration, IANAZone } from "luxon";
 //#region src/batteries/tools/datetime_math/index.ts

package/batteries/tools/encoding.cjs

@@ -1,8 +1,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 require("../../chunk-Ble4zEEl.js");
-const require_tool_registry = require("../../tool_registry-CtCQ4Xoz.js");
-const require_tool = require("../../tool-CX9vNHAw.js");
-require("../../common-D_e5zYsG.js");
+const require_tool_registry = require("../../tool_registry-DYUYqXvo.js");
+const require_tool = require("../../tool-CVyZkFC7.js");
+require("../../common-Cj8TaQ9U.js");
 require("../../guards.cjs");
 let _nhtio_validation = require("@nhtio/validation");
 //#region src/batteries/tools/encoding/index.ts

package/batteries/tools/encoding.mjs

@@ -1,6 +1,6 @@
-import { o as isError } from "../../tool_registry-BGHg6KTq.mjs";
-import { t as Tool } from "../../tool-CRZSUcdP.mjs";
-import "../../common-lMrnzoyn.mjs";
+import { o as isError } from "../../tool_registry-D1pSSlsd.mjs";
+import { t as Tool } from "../../tool-CMhaDRNd.mjs";
+import "../../common-BT0nfCi9.mjs";
 import "../../guards.mjs";
 import { validator } from "@nhtio/validation";
 //#region src/batteries/tools/encoding/index.ts

package/batteries/tools/formatting.cjs

@@ -1,8 +1,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 require("../../chunk-Ble4zEEl.js");
-const require_tool_registry = require("../../tool_registry-CtCQ4Xoz.js");
-const require_tool = require("../../tool-CX9vNHAw.js");
-require("../../common-D_e5zYsG.js");
+const require_tool_registry = require("../../tool_registry-DYUYqXvo.js");
+const require_tool = require("../../tool-CVyZkFC7.js");
+require("../../common-Cj8TaQ9U.js");
 require("../../guards.cjs");
 let _nhtio_validation = require("@nhtio/validation");
 //#region src/batteries/tools/formatting/index.ts

package/batteries/tools/formatting.mjs

@@ -1,6 +1,6 @@
-import { o as isError } from "../../tool_registry-BGHg6KTq.mjs";
-import { t as Tool } from "../../tool-CRZSUcdP.mjs";
-import "../../common-lMrnzoyn.mjs";
+import { o as isError } from "../../tool_registry-D1pSSlsd.mjs";
+import { t as Tool } from "../../tool-CMhaDRNd.mjs";
+import "../../common-BT0nfCi9.mjs";
 import "../../guards.mjs";
 import { validator } from "@nhtio/validation";
 //#region src/batteries/tools/formatting/index.ts

package/batteries/tools/geo_basics.cjs

@@ -1,7 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 require("../../chunk-Ble4zEEl.js");
-const require_tool = require("../../tool-CX9vNHAw.js");
-require("../../common-D_e5zYsG.js");
+const require_tool = require("../../tool-CVyZkFC7.js");
+require("../../common-Cj8TaQ9U.js");
 let _nhtio_validation = require("@nhtio/validation");
 //#region src/batteries/tools/geo_basics/index.ts
 /**

package/batteries/tools/geo_basics.mjs

@@ -1,5 +1,5 @@
-import { t as Tool } from "../../tool-CRZSUcdP.mjs";
-import "../../common-lMrnzoyn.mjs";
+import { t as Tool } from "../../tool-CMhaDRNd.mjs";
+import "../../common-BT0nfCi9.mjs";
 import { validator } from "@nhtio/validation";
 //#region src/batteries/tools/geo_basics/index.ts
 /**

package/batteries/tools/math/index.d.ts

@@ -24,13 +24,24 @@ import { Tool } from "../../../common";
  */
 export declare const calculateTool: Tool<import("../../../common").SpooledArtifact>;
 /**
- * Translates a LaTeX/KaTeX expression into mathjs syntax, evaluates it, and returns the result.
+ * Translates a LaTeX/KaTeX expression using evaluatex and returns the numeric result.
  *
  * @remarks
- * Translates common LaTeX constructs (`\frac{a}{b}`, `\sqrt{...}`, `\cdot`, `\times`, Greek
- * macros like `\pi`, `\left`/`\right` delimiters, `\text{...}`, subscripts, etc.) into their
- * mathjs equivalents before evaluation. Both the source and the translated mathjs expression
- * are subject to the 1000-character length cap.
+ * Uses the evaluatex library to parse and evaluate LaTeX expressions. Handles common constructs
+ * (`\frac{a}{b}`, `\sqrt{...}`, `\cdot`, `\times`, Greek macros like `\pi`, inverse trig,
+ * `\left`/`\right` delimiters, `\text{...}`, subscripts, etc.) with a proper parser rather than
+ * brittle regex.
+ *
+ * Also evaluates three calculus constructs **numerically** (mathjs has no symbolic integration, and
+ * its symbolic `derivative` is blocklisted here for safety):
+ * - Definite integrals — `\int_{a}^{b} f \,dx` via composite Simpson quadrature.
+ * - Derivatives at a point — `\frac{d}{dx} f \big|_{x=a}` via central finite difference.
+ * - Limits — `\lim_{x \to a} f` (including `a = \pm\infty`) via a two-sided numeric approach.
+ *
+ * Numeric results are rounded with `math.format(..., { precision: 12 })` and labelled
+ * `Result (numeric):` to flag that they are approximations. Constructs that cannot be evaluated
+ * numerically (indefinite integrals, derivatives without a point, infinite integration bounds,
+ * singular integrands, divergent limits) return a specific, guiding error string.
  *
  * Parse and evaluation errors are returned as error strings rather than thrown.
  */

package/batteries/tools/math.cjs

@@ -1,11 +1,13 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-require("../../chunk-Ble4zEEl.js");
-const require_tool_registry = require("../../tool_registry-CtCQ4Xoz.js");
-const require_tool = require("../../tool-CX9vNHAw.js");
-require("../../common-D_e5zYsG.js");
+const require_chunk = require("../../chunk-Ble4zEEl.js");
+const require_tool_registry = require("../../tool_registry-DYUYqXvo.js");
+const require_tool = require("../../tool-CVyZkFC7.js");
+require("../../common-Cj8TaQ9U.js");
 require("../../guards.cjs");
 let _nhtio_validation = require("@nhtio/validation");
 let mathjs = require("mathjs");
+let evaluatex = require("evaluatex");
+evaluatex = require_chunk.__toESM(evaluatex);
 //#region src/batteries/tools/math/index.ts
 /**
 * Pre-constructed tools for safe arithmetic, expression evaluation, and numeric operations.
@@ -32,20 +34,110 @@ function validateExpression(expr) {
 	if (expr.length > MAX_EXPRESSION_LENGTH) return `Expression too long (max ${MAX_EXPRESSION_LENGTH} characters).`;
 }
 /**
-* Convert common LaTeX/KaTeX notation to a mathjs-evaluable expression.
+* EvaluateX scope providing constants and function aliases that evaluatex does not ship
+* out-of-the-box, matching the capabilities that were previously provided by the mathjs
+* translation layer.
 */
-function latexToMathjs(latex) {
+var EVALUATEX_SCOPE = {
+	pi: Math.PI,
+	e: Math.E,
+	infinity: Infinity,
+	alpha: void 0,
+	beta: void 0,
+	gamma: void 0,
+	delta: void 0,
+	epsilon: void 0,
+	theta: void 0,
+	lambda: void 0,
+	mu: void 0,
+	sigma: void 0,
+	tau: void 0,
+	phi: void 0,
+	omega: void 0,
+	ln: Math.log,
+	log10: (x) => Math.log(x) / Math.LN10,
+	log2: (x) => Math.log(x) / Math.LN2,
+	nthRoot: (x, n) => Math.pow(x, 1 / n),
+	det: (x) => x
+};
+/**
+* Translate a LaTeX/KaTeX expression to evaluatex-compatible syntax and evaluate it.
+*
+* The translation is a lightweight pass over the LaTeX source that handles common constructs
+* (frac, sqrt, trig, Greek macros, delimiters, etc.) and feeds the result to evaluatex with
+* a pre-built scope providing constants and function aliases. This replaces the previous
+* hand-rolled regex → mathjs pipeline.
+*/
+function evaluateLatex(latex) {
 	let expr = latex.trim();
 	expr = expr.replace(/^\$\$?|\$\$?$/g, "");
 	expr = expr.replace(/^\\[[(]|\\[\])]$/g, "");
-	for (let i = 0; i < 10; i++) {
+	for (let i = 0; i < 20; i++) {
 		const before = expr;
-		expr = expr.replace(/\\frac\s*\{([^{}]*)\}\s*\{([^{}]*)\}/g, "(($1)/($2))");
+		expr = expr.replace(/\\frac\s*\{([^}]*)\}\s*\{([^}]*)\}/g, "($1)/($2)");
 		if (expr === before) break;
 	}
-	expr = expr.replace(/\\sqrt\[([^\]]+)\]\s*\{([^{}]*)\}/g, "nthRoot($2, $1)");
-	expr = expr.replace(/\\sqrt\s*\{([^{}]*)\}/g, "sqrt($1)");
-	expr = expr.replace(/\\(sin|cos|tan|cot|sec|csc|arcsin|arccos|arctan|sinh|cosh|tanh|ln|log|exp|abs|det)/g, "$1");
+	expr = expr.replace(/\\sqrt\[([^\]]+)\]\s*\{([^}]*)\}/g, "nthRoot($2, $1)");
+	expr = expr.replace(/\\sqrt\s*\{([^}]*)\}/g, "sqrt($1)");
+	expr = expr.replace(/\\arcsin/g, "asin");
+	expr = expr.replace(/\\arccos/g, "acos");
+	expr = expr.replace(/\\arctan/g, "atan");
+	expr = expr.replace(/\\(sin|cos|tan|cot|sec|csc|sinh|cosh|tanh|ln|log|exp|abs|det)/g, "$1");
+	expr = expr.replace(/log_\{?(\w+)\}?\(/g, (_, base) => {
+		const baseLower = base.toLowerCase();
+		if (baseLower === "10") return "log10(";
+		if (baseLower === "2") return "log2(";
+		if (baseLower === "e") return "ln(";
+		return `ln(/ln(${base})`;
+	});
+	expr = expr.replace(/_\{[^}]*\}/g, "");
+	expr = expr.replace(/_\w/g, "");
+	expr = expr.replace(/\^{([^{}]*)}/g, "^($1)");
+	expr = expr.replace(/\\pi/g, "pi");
+	expr = expr.replace(/\\(alpha|beta|gamma|delta|epsilon|theta|lambda|mu|sigma|tau|phi|omega)/g, "$1");
+	expr = expr.replace(/\\cdot/g, "*");
+	expr = expr.replace(/\\times/g, "*");
+	expr = expr.replace(/\\div/g, "/");
+	expr = expr.replace(/\\infty/g, "infinity");
+	expr = expr.replace(/\\left\s*([([{|])/g, "$1");
+	expr = expr.replace(/\\right\s*([)\]}|])/g, "$1");
+	expr = expr.replace(/\\sum/g, "sum");
+	expr = expr.replace(/\\prod/g, "prod");
+	expr = expr.replace(/\\,/g, " ");
+	expr = expr.replace(/\\;/g, " ");
+	expr = expr.replace(/\\quad/g, " ");
+	expr = expr.replace(/\\qquad/g, " ");
+	expr = expr.replace(/\\text\{([^{}]*)\}/g, "");
+	expr = expr.replace(/(\d)([a-zA-Z(])/g, "$1*$2");
+	expr = expr.replace(/\)\s*\(/g, ")*(");
+	expr = expr.replace(/\s+/g, " ").trim();
+	const result = (0, evaluatex.default)(expr, EVALUATEX_SCOPE)();
+	if (typeof result !== "number" || !Number.isFinite(result)) throw new Error("Result is not finite");
+	return result;
+}
+/**
+* Lightweight LaTeX-to-string translator for internal use by the numeric calculus path.
+*
+* This is the same translation pass as {@link evaluateLatex}, but returns the translated string
+* (compatible with mathjs syntax) rather than evaluating it. Used by the calculus handlers to
+* convert integrands, function bodies, and bound expressions before passing them to
+* `math.evaluate` for specific-point evaluation.
+*/
+function translateLatex(latex) {
+	let expr = latex.trim();
+	expr = expr.replace(/^\$\$?|\$\$?$/g, "");
+	expr = expr.replace(/^\\[[(]|\\[\])]$/g, "");
+	for (let i = 0; i < 20; i++) {
+		const before = expr;
+		expr = expr.replace(/\\frac\s*\{([^}]*)\}\s*\{([^}]*)\}/g, "($1)/($2)");
+		if (expr === before) break;
+	}
+	expr = expr.replace(/\\sqrt\[([^\]]+)\]\s*\{([^}]*)\}/g, "nthRoot($2, $1)");
+	expr = expr.replace(/\\sqrt\s*\{([^}]*)\}/g, "sqrt($1)");
+	expr = expr.replace(/\\arcsin/g, "asin");
+	expr = expr.replace(/\\arccos/g, "acos");
+	expr = expr.replace(/\\arctan/g, "atan");
+	expr = expr.replace(/\\(sin|cos|tan|cot|sec|csc|sinh|cosh|tanh|ln|log|exp|abs|det)/g, "$1");
 	expr = expr.replace(/log_\{?(\w+)\}?\s*\(([^)]+)\)/g, "log($2, $1)");
 	expr = expr.replace(/\^{([^{}]*)}/g, "^($1)");
 	expr = expr.replace(/_\{[^{}]*\}/g, "");
@@ -70,6 +162,222 @@ function latexToMathjs(latex) {
 	expr = expr.replace(/\s+/g, " ").trim();
 	return expr;
 }
+/** A tagged error whose message is surfaced to the model verbatim (caught by {@link tryCalculus}). */
+var CalculusError = class extends Error {};
+/** Evaluate a mathjs expression at a single point, guarding against non-finite results. */
+function evalAt(expr, varName, x) {
+	const y = math.evaluate(expr, { [varName]: x });
+	if (typeof y !== "number" || !Number.isFinite(y)) throw new CalculusError("NON_FINITE");
+	return y;
+}
+/** Composite Simpson's rule over a finite interval. Throws {@link CalculusError} on a singularity. */
+function simpson(fn, a, b, n = 1e3) {
+	if (n % 2 === 1) n++;
+	const h = (b - a) / n;
+	let sum = fn(a) + fn(b);
+	for (let i = 1; i < n; i++) sum += (i % 2 === 1 ? 4 : 2) * fn(a + i * h);
+	const result = h / 3 * sum;
+	if (!Number.isFinite(result)) throw new CalculusError("NON_FINITE");
+	return result;
+}
+/** Round numeric output to 12 significant digits, collapsing floating-point noise. */
+function formatNumeric(n) {
+	if (Math.abs(n) < 1e-9) return "0";
+	return math.format(n, { precision: 12 });
+}
+/**
+* Reads a single `_`/`^` script starting at `i`, supporting braced (`_{0}`, `^{\pi}`), command
+* (`^\pi`), and bare-token (`_0`, `^1`) forms. Returns the mark, its raw-LaTeX value, and the next
+* index, or `null` when there is no script at `i`.
+*/
+function readScript(s, i) {
+	while (s[i] === " ") i++;
+	const mark = s[i];
+	if (mark !== "_" && mark !== "^") return null;
+	i++;
+	while (s[i] === " ") i++;
+	if (s[i] === "{") {
+		let depth = 0;
+		const start = ++i;
+		for (; i < s.length; i++) if (s[i] === "{") depth++;
+		else if (s[i] === "}") {
+			if (depth === 0) break;
+			depth--;
+		}
+		return {
+			mark,
+			val: s.slice(start, i),
+			next: i + 1
+		};
+	}
+	if (s[i] === "\\") {
+		const m = /^\\[a-zA-Z]+/.exec(s.slice(i));
+		if (!m) return null;
+		return {
+			mark,
+			val: m[0],
+			next: i + m[0].length
+		};
+	}
+	const m = /^[A-Za-z0-9.]+/.exec(s.slice(i));
+	if (!m) return null;
+	return {
+		mark,
+		val: m[0],
+		next: i + m[0].length
+	};
+}
+/** Translate a raw-LaTeX bound/target fragment and evaluate it to a finite number. */
+function evalBound(latex) {
+	const trimmed = latex.trim();
+	if (/\\infty/.test(trimmed)) throw new CalculusError("INFINITE_BOUND");
+	const mathjsExpr = translateLatex(trimmed);
+	const value = math.evaluate(mathjsExpr);
+	if (typeof value !== "number" || !Number.isFinite(value)) throw new CalculusError("BAD_BOUND");
+	return value;
+}
+/** Evaluate a definite integral `\int_{a}^{b} f \,dx` by Simpson quadrature. */
+function evalIntegral(s) {
+	const m = /\\int(?:\\limits)?/.exec(s);
+	if (!m) throw new CalculusError("NOT_INTEGRAL");
+	let i = m.index + m[0].length;
+	const scripts = {
+		"_": void 0,
+		"^": void 0
+	};
+	for (let k = 0; k < 2; k++) {
+		const sc = readScript(s, i);
+		if (!sc) break;
+		scripts[sc.mark] = sc.val;
+		i = sc.next;
+	}
+	if (scripts._ === void 0 || scripts["^"] === void 0) throw new CalculusError("INDEFINITE");
+	const rest = s.slice(i);
+	const diff = /\\?,?\s*\bd\s*([a-zA-Z])\s*$/.exec(rest);
+	if (!diff) throw new CalculusError("NO_DIFFERENTIAL");
+	const variable = diff[1];
+	const integrandLatex = rest.slice(0, diff.index);
+	if (integrandLatex.trim().length === 0) throw new CalculusError("NO_INTEGRAND");
+	const a = evalBound(scripts._);
+	const b = evalBound(scripts["^"]);
+	const integrand = translateLatex(integrandLatex);
+	const fn = (x) => evalAt(integrand, variable, x);
+	let result;
+	if (a === b) result = 0;
+	else if (a < b) result = simpson(fn, a, b);
+	else result = -simpson(fn, b, a);
+	return `Converted: ∫(${integrand}) d${variable} from ${formatNumeric(a)} to ${formatNumeric(b)}\nResult (numeric): ${formatNumeric(result)}`;
+}
+/** Evaluate a derivative `\frac{d}{dx} f \big|_{x=a}` at a point via central finite difference. */
+function evalDerivative(s) {
+	let variable;
+	let body = s;
+	const fracOp = /\\frac\s*\{\s*d\s*\}\s*\{\s*d\s*([a-zA-Z])\s*\}/.exec(s);
+	if (fracOp) {
+		variable = fracOp[1];
+		body = s.slice(fracOp.index + fracOp[0].length);
+	} else {
+		const bareOp = /(?:^|[^a-zA-Z])d\s*\/\s*d([a-zA-Z])/.exec(s);
+		if (bareOp) {
+			variable = bareOp[1];
+			body = s.slice(bareOp.index + bareOp[0].length);
+		}
+	}
+	if (!variable) throw new CalculusError("NOT_DERIVATIVE");
+	body = body.replace(/\\left\.?/g, "").replace(/\\right\.?/g, "");
+	const bar = /\\?(?:Big|big|bigg|Bigg)?\s*\|\s*_\s*\{?\s*([a-zA-Z])\s*=\s*([^}]+?)\s*\}?\s*$/.exec(body);
+	if (!bar) throw new CalculusError("NO_POINT");
+	const point = evalBound(bar[2]);
+	let fnLatex = body.slice(0, bar.index).trim();
+	fnLatex = fnLatex.replace(/^\\?\(([\s\S]*)\\?\)$/, "$1").replace(/^\[([\s\S]*)\]$/, "$1").trim();
+	if (fnLatex.length === 0) throw new CalculusError("NO_FUNCTION");
+	const expr = translateLatex(fnLatex);
+	const h = 1e-6;
+	const fn = (x) => evalAt(expr, variable, x);
+	const result = (fn(point + h) - fn(point - h)) / (2 * h);
+	if (!Number.isFinite(result)) throw new CalculusError("NON_FINITE");
+	return `Converted: d/d${variable}(${expr}) at ${variable}=${formatNumeric(point)}\nResult (numeric): ${formatNumeric(result)}`;
+}
+/** Evaluate a limit `\lim_{x \to a} f(x)` by a two-sided numeric approach. */
+function evalLimit(s) {
+	const head = /\\lim\s*_\s*\{\s*([a-zA-Z])\s*\\to\s*([\s\S]+?)\s*\}/.exec(s);
+	if (!head) throw new CalculusError("NOT_LIMIT");
+	const variable = head[1];
+	let targetLatex = head[2].trim();
+	const bodyLatex = s.slice(head.index + head[0].length).trim();
+	if (bodyLatex.length === 0) throw new CalculusError("NO_FUNCTION");
+	let side = "both";
+	const oneSided = /\^\s*\{?\s*([+-])\s*\}?\s*$/.exec(targetLatex);
+	if (oneSided) {
+		side = oneSided[1] === "+" ? "plus" : "minus";
+		targetLatex = targetLatex.slice(0, oneSided.index).trim();
+	}
+	const expr = translateLatex(bodyLatex);
+	const fn = (x) => evalAt(expr, variable, x);
+	const eps = 1e-6;
+	let result;
+	let targetLabel;
+	if (/^-\s*\\infty$/.test(targetLatex)) {
+		result = fn(-1e8);
+		targetLabel = "-∞";
+	} else if (/^\\infty$/.test(targetLatex)) {
+		result = fn(1e8);
+		targetLabel = "∞";
+	} else {
+		const target = evalBound(targetLatex);
+		targetLabel = formatNumeric(target);
+		if (side === "plus") result = fn(target + eps);
+		else if (side === "minus") result = fn(target - eps);
+		else {
+			const lo = fn(target - eps);
+			const hi = fn(target + eps);
+			const avg = (lo + hi) / 2;
+			if (Math.abs(hi - lo) > .001 * Math.max(1, Math.abs(avg))) throw new CalculusError("LIMIT_MISMATCH");
+			result = avg;
+		}
+	}
+	if (!Number.isFinite(result)) throw new CalculusError("LIMIT_UNBOUNDED");
+	const nearest = Math.round(result);
+	if (Math.abs(result - nearest) < 1e-6) result = nearest;
+	return `Converted: lim ${variable}→${targetLabel} of (${expr})\nResult (numeric): ${formatNumeric(result)}`;
+}
+/** Human-readable, model-actionable message for each {@link CalculusError} tag. */
+function calculusErrorMessage(tag) {
+	switch (tag) {
+		case "INDEFINITE": return "Cannot evaluate an indefinite integral numerically. Provide bounds, e.g. \\int_{0}^{1} x dx.";
+		case "NO_DIFFERENTIAL": return "Could not find the integration variable. Expected a trailing differential like 'dx'.";
+		case "NO_INTEGRAND": return "The integral has no integrand to evaluate.";
+		case "INFINITE_BOUND": return "Infinite integration bounds are not supported. Provide finite numeric bounds, e.g. \\int_{0}^{1} f dx.";
+		case "BAD_BOUND": return "Could not evaluate the integration bounds to numbers.";
+		case "NO_POINT": return "Cannot evaluate a derivative numerically without a point. Specify where, e.g. \\frac{d}{dx}(x^2)\\Big|_{x=3}.";
+		case "NO_FUNCTION": return "Could not find the function to evaluate.";
+		case "LIMIT_MISMATCH": return "The limit may not exist (left and right values disagree).";
+		case "LIMIT_UNBOUNDED": return "The limit appears to diverge (function is unbounded near the target).";
+		case "NON_FINITE": return "The expression is not finite over the requested range (possible singularity); cannot evaluate numerically.";
+		default: return "Could not evaluate the calculus expression.";
+	}
+}
+/**
+* Detects a calculus construct in raw LaTeX and routes it to the matching numeric handler. Returns
+* the result/error string, or `null` when the input is not a calculus expression (so the caller
+* falls through to the scalar evaluation path unchanged).
+*/
+function tryCalculus(latex) {
+	let s = latex.trim();
+	s = s.replace(/^\$\$?|\$\$?$/g, "");
+	s = s.replace(/^\\[[(]|\\[\])]$/g, "").trim();
+	let handler;
+	if (/\\int/.test(s)) handler = evalIntegral;
+	else if (/\\lim/.test(s)) handler = evalLimit;
+	else if (/\\frac\s*\{\s*d\s*\}\s*\{\s*d\s*[a-zA-Z]\s*\}/.test(s) || /(?:^|[^a-zA-Z])d\s*\/\s*d[a-zA-Z]/.test(s)) handler = evalDerivative;
+	if (!handler) return null;
+	try {
+		return handler(s);
+	} catch (err) {
+		if (require_tool_registry.isInstanceOf(err, "CalculusError", CalculusError)) return `Error: ${calculusErrorMessage(err.message)}`;
+		return `Error: ${require_tool_registry.isError(err) ? err.message : String(err)}`;
+	}
+}
 /**
 * Evaluates a mathjs-syntax expression and returns the numeric result alongside the KaTeX
 * representation of the parsed expression.
@@ -101,29 +409,39 @@ var calculateTool = new require_tool.Tool({
 	}
 });
 /**
-* Translates a LaTeX/KaTeX expression into mathjs syntax, evaluates it, and returns the result.
+* Translates a LaTeX/KaTeX expression using evaluatex and returns the numeric result.
 *
 * @remarks
-* Translates common LaTeX constructs (`\frac{a}{b}`, `\sqrt{...}`, `\cdot`, `\times`, Greek
-* macros like `\pi`, `\left`/`\right` delimiters, `\text{...}`, subscripts, etc.) into their
-* mathjs equivalents before evaluation. Both the source and the translated mathjs expression
-* are subject to the 1000-character length cap.
+* Uses the evaluatex library to parse and evaluate LaTeX expressions. Handles common constructs
+* (`\frac{a}{b}`, `\sqrt{...}`, `\cdot`, `\times`, Greek macros like `\pi`, inverse trig,
+* `\left`/`\right` delimiters, `\text{...}`, subscripts, etc.) with a proper parser rather than
+* brittle regex.
+*
+* Also evaluates three calculus constructs **numerically** (mathjs has no symbolic integration, and
+* its symbolic `derivative` is blocklisted here for safety):
+* - Definite integrals — `\int_{a}^{b} f \,dx` via composite Simpson quadrature.
+* - Derivatives at a point — `\frac{d}{dx} f \big|_{x=a}` via central finite difference.
+* - Limits — `\lim_{x \to a} f` (including `a = \pm\infty`) via a two-sided numeric approach.
+*
+* Numeric results are rounded with `math.format(..., { precision: 12 })` and labelled
+* `Result (numeric):` to flag that they are approximations. Constructs that cannot be evaluated
+* numerically (indefinite integrals, derivatives without a point, infinite integration bounds,
+* singular integrands, divergent limits) return a specific, guiding error string.
 *
 * Parse and evaluation errors are returned as error strings rather than thrown.
 */
 var evaluateKatexTool = new require_tool.Tool({
 	name: "evaluate_katex",
-	description: "Evaluate a KaTeX/LaTeX math expression and return the numeric result.",
-	inputSchema: _nhtio_validation.validator.object({ katex: _nhtio_validation.validator.string().required().description("LaTeX expression, e.g. \"\\frac{1}{2} + \\sqrt{9}\"") }),
+	description: "Evaluate a KaTeX/LaTeX math expression and return the numeric result. Supports arithmetic, trig, logs, roots, and numeric calculus: definite integrals (\\int_{a}^{b} f dx), derivatives at a point (\\frac{d}{dx} f|_{x=a}), and limits (\\lim_{x \\to a} f).",
+	inputSchema: _nhtio_validation.validator.object({ katex: _nhtio_validation.validator.string().required().description("LaTeX expression, e.g. \"\\frac{1}{2} + \\sqrt{9}\" or \"\\int_{0}^{1} x^2 dx\"") }),
 	handler: async (args) => {
 		const { katex } = args;
 		const lengthError = validateExpression(katex);
 		if (lengthError) return lengthError;
 		try {
-			const mathjsExpr = latexToMathjs(katex);
-			const translatedLengthError = validateExpression(mathjsExpr);
-			if (translatedLengthError) return translatedLengthError;
-			return `Converted: ${mathjsExpr}\nResult: ${math.evaluate(mathjsExpr)}`;
+			const calculus = tryCalculus(katex);
+			if (calculus !== null) return calculus;
+			return `Result: ${evaluateLatex(katex)}`;
 		} catch (err) {
 			return `Error: ${require_tool_registry.isError(err) ? err.message : String(err)}`;
 		}