@nhtio/adk 0.1.0-master-f0aa531d

package/batteries/tools/index.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Aggregate barrel for every pre-constructed bundled tool category.
+ *
+ * @module @nhtio/adk/batteries/tools
+ *
+ * @remarks
+ * Aggregate barrel of every bundled tool category. Re-exports each category's tools as named
+ * exports so consumers can
+ * `import { calculateTool, formatTableTool } from '@nhtio/adk/batteries/tools'`. Each category
+ * is also exposed as its own subpath (`@nhtio/adk/batteries/tools/<category>`) for
+ * finer-grained tree-shaking.
+ */
+export * from "./color/index";
+export * from "./comparison/index";
+export * from "./data_structure/index";
+export * from "./datetime_extended/index";
+export * from "./datetime_math/index";
+export * from "./encoding/index";
+export * from "./formatting/index";
+export * from "./geo_basics/index";
+export * from "./math/index";
+export * from "./memory/index";
+export * from "./parsing/index";
+export * from "./retrievables/index";
+export * from "./standing_instructions/index";
+export * from "./statistics/index";
+export * from "./string_processing/index";
+export * from "./structured_data/index";
+export * from "./text_analysis/index";
+export * from "./text_comparison/index";
+export * from "./time/index";
+export * from "./unit_conversion/index";

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

@@ -0,0 +1,37 @@
+/**
+ * Pre-constructed tools for safe arithmetic, expression evaluation, and numeric operations.
+ *
+ * @module @nhtio/adk/batteries/tools/math
+ *
+ * @remarks
+ * Pre-constructed bundled tools for the `math` category. Import individually, the whole
+ * category, or import every tool via `@nhtio/adk/batteries`.
+ */
+import { Tool } from "../../../common";
+/**
+ * Evaluates a mathjs-syntax expression and returns the numeric result alongside the KaTeX
+ * representation of the parsed expression.
+ *
+ * @remarks
+ * Supports arithmetic, trigonometric, logarithmic, exponential, factorial, matrix, and unit
+ * operations via `mathjs`. The mathjs instance is hardened: dangerous functions (`import`,
+ * `createUnit`, `simplify`, `derivative`, `compile`, `chain`, `reviver`, `replacer`) are
+ * disabled to prevent interpreter-surface exposure.
+ *
+ * Expressions over 1000 characters are rejected with an error string (not thrown). Parse and
+ * evaluation errors are also returned as error strings — the tool surfaces math errors as
+ * content rather than exceptions, so the model can react to them in-line.
+ */
+export declare const calculateTool: Tool<import("../../../common").SpooledArtifact>;
+/**
+ * Translates a LaTeX/KaTeX expression into mathjs syntax, evaluates it, and returns the 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.
+ *
+ * Parse and evaluation errors are returned as error strings rather than thrown.
+ */
+export declare const evaluateKatexTool: Tool<import("../../../common").SpooledArtifact>;

package/batteries/tools/math.cjs

@@ -0,0 +1,136 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("../../chunk-KmRHZBOW.js");
+const require_tool_registry = require("../../tool_registry-Dkfprsck.js");
+require("../../common-Od8edUXU.js");
+const require_tool = require("../../tool-COSeH8I6.js");
+require("../../guards.cjs");
+let _nhtio_validation = require("@nhtio/validation");
+let mathjs = require("mathjs");
+//#region src/batteries/tools/math/index.ts
+/**
+* Pre-constructed tools for safe arithmetic, expression evaluation, and numeric operations.
+*
+* @module @nhtio/adk/batteries/tools/math
+*
+* @remarks
+* Pre-constructed bundled tools for the `math` category. Import individually, the whole
+* category, or import every tool via `@nhtio/adk/batteries`.
+*/
+var math = (0, mathjs.create)(mathjs.all);
+for (const fn of [
+	"import",
+	"createUnit",
+	"simplify",
+	"derivative",
+	"compile",
+	"chain",
+	"reviver",
+	"replacer"
+]) if (fn in math) math[fn] = void 0;
+var MAX_EXPRESSION_LENGTH = 1e3;
+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.
+*/
+function latexToMathjs(latex) {
+	let expr = latex.trim();
+	expr = expr.replace(/^\$\$?|\$\$?$/g, "");
+	expr = expr.replace(/^\\[[(]|\\[\])]$/g, "");
+	for (let i = 0; i < 10; 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(/\\(sin|cos|tan|cot|sec|csc|arcsin|arccos|arctan|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, "");
+	expr = expr.replace(/_\w/g, "");
+	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();
+	return expr;
+}
+/**
+* Evaluates a mathjs-syntax expression and returns the numeric result alongside the KaTeX
+* representation of the parsed expression.
+*
+* @remarks
+* Supports arithmetic, trigonometric, logarithmic, exponential, factorial, matrix, and unit
+* operations via `mathjs`. The mathjs instance is hardened: dangerous functions (`import`,
+* `createUnit`, `simplify`, `derivative`, `compile`, `chain`, `reviver`, `replacer`) are
+* disabled to prevent interpreter-surface exposure.
+*
+* Expressions over 1000 characters are rejected with an error string (not thrown). Parse and
+* evaluation errors are also returned as error strings — the tool surfaces math errors as
+* content rather than exceptions, so the model can react to them in-line.
+*/
+var calculateTool = new require_tool.Tool({
+	name: "calculate",
+	description: "Evaluate a math expression. Supports arithmetic, trig, log, sqrt, factorial, matrices.",
+	inputSchema: _nhtio_validation.validator.object({ expression: _nhtio_validation.validator.string().required().description("Math expression, e.g. \"sin(pi/4) + 5!\"") }),
+	handler: async (args) => {
+		const { expression } = args;
+		const lengthError = validateExpression(expression);
+		if (lengthError) return lengthError;
+		try {
+			const result = math.evaluate(expression);
+			return `Result: ${result}\nKaTeX: $${math.parse(expression).toTex()} = ${result}$`;
+		} catch (err) {
+			return `Error: ${require_tool_registry.isError(err) ? err.message : String(err)}`;
+		}
+	}
+});
+/**
+* Translates a LaTeX/KaTeX expression into mathjs syntax, evaluates it, and returns the 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.
+*
+* 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}\"") }),
+	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)}`;
+		} catch (err) {
+			return `Error: ${require_tool_registry.isError(err) ? err.message : String(err)}`;
+		}
+	}
+});
+//#endregion
+exports.calculateTool = calculateTool;
+exports.evaluateKatexTool = evaluateKatexTool;
+
+//# sourceMappingURL=math.cjs.map

package/batteries/tools/math.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"math.cjs","names":[],"sources":["../../../src/batteries/tools/math/index.ts"],"sourcesContent":["/**\n * Pre-constructed tools for safe arithmetic, expression evaluation, and numeric operations.\n *\n * @module @nhtio/adk/batteries/tools/math\n *\n * @remarks\n * Pre-constructed bundled tools for the `math` category. Import individually, the whole\n * category, or import every tool via `@nhtio/adk/batteries`.\n */\n\nimport { create, all } from 'mathjs'\nimport { Tool } from '@nhtio/adk/common'\nimport { isError } from '@nhtio/adk/guards'\nimport { validator } from '@nhtio/validation'\n\nconst math = create(all)\n\nconst BLOCKED_FUNCTIONS = [\n  'import',\n  'createUnit',\n  'simplify',\n  'derivative',\n  'compile',\n  'chain',\n  'reviver',\n  'replacer',\n]\n\nfor (const fn of BLOCKED_FUNCTIONS) {\n  if (fn in math) {\n    ;(math as any)[fn] = undefined\n  }\n}\n\nconst MAX_EXPRESSION_LENGTH = 1000\n\nfunction validateExpression(expr: string): string | undefined {\n  if (expr.length > MAX_EXPRESSION_LENGTH) {\n    return `Expression too long (max ${MAX_EXPRESSION_LENGTH} characters).`\n  }\n  return undefined\n}\n\n/**\n * Convert common LaTeX/KaTeX notation to a mathjs-evaluable expression.\n */\nfunction latexToMathjs(latex: string): string {\n  let expr = latex.trim()\n\n  expr = expr.replace(/^\\$\\$?|\\$\\$?$/g, '')\n  expr = expr.replace(/^\\\\[[(]|\\\\[\\])]$/g, '')\n\n  for (let i = 0; i < 10; i++) {\n    const before = expr\n    expr = expr.replace(/\\\\frac\\s*\\{([^{}]*)\\}\\s*\\{([^{}]*)\\}/g, '(($1)/($2))')\n    if (expr === before) break\n  }\n\n  expr = expr.replace(/\\\\sqrt\\[([^\\]]+)\\]\\s*\\{([^{}]*)\\}/g, 'nthRoot($2, $1)')\n  expr = expr.replace(/\\\\sqrt\\s*\\{([^{}]*)\\}/g, 'sqrt($1)')\n\n  expr = expr.replace(\n    /\\\\(sin|cos|tan|cot|sec|csc|arcsin|arccos|arctan|sinh|cosh|tanh|ln|log|exp|abs|det)/g,\n    '$1'\n  )\n\n  expr = expr.replace(/log_\\{?(\\w+)\\}?\\s*\\(([^)]+)\\)/g, 'log($2, $1)')\n  expr = expr.replace(/\\^{([^{}]*)}/g, '^($1)')\n  expr = expr.replace(/_\\{[^{}]*\\}/g, '')\n  expr = expr.replace(/_\\w/g, '')\n\n  expr = expr.replace(/\\\\pi/g, 'pi')\n  expr = expr.replace(\n    /\\\\(alpha|beta|gamma|delta|epsilon|theta|lambda|mu|sigma|tau|phi|omega)/g,\n    '$1'\n  )\n\n  expr = expr.replace(/\\\\cdot/g, '*')\n  expr = expr.replace(/\\\\times/g, '*')\n  expr = expr.replace(/\\\\div/g, '/')\n  expr = expr.replace(/\\\\infty/g, 'Infinity')\n  expr = expr.replace(/\\\\left\\s*([([{|])/g, '$1')\n  expr = expr.replace(/\\\\right\\s*([)\\]}|])/g, '$1')\n  expr = expr.replace(/\\\\sum/g, 'sum')\n  expr = expr.replace(/\\\\prod/g, 'prod')\n  expr = expr.replace(/\\\\,/g, ' ')\n  expr = expr.replace(/\\\\;/g, ' ')\n  expr = expr.replace(/\\\\quad/g, ' ')\n  expr = expr.replace(/\\\\qquad/g, ' ')\n  expr = expr.replace(/\\\\text\\{([^{}]*)\\}/g, '')\n  expr = expr.replace(/(\\d)([a-zA-Z(])/g, '$1*$2')\n  expr = expr.replace(/\\)\\s*\\(/g, ')*(')\n  expr = expr.replace(/\\s+/g, ' ').trim()\n\n  return expr\n}\n\n/**\n * Evaluates a mathjs-syntax expression and returns the numeric result alongside the KaTeX\n * representation of the parsed expression.\n *\n * @remarks\n * Supports arithmetic, trigonometric, logarithmic, exponential, factorial, matrix, and unit\n * operations via `mathjs`. The mathjs instance is hardened: dangerous functions (`import`,\n * `createUnit`, `simplify`, `derivative`, `compile`, `chain`, `reviver`, `replacer`) are\n * disabled to prevent interpreter-surface exposure.\n *\n * Expressions over 1000 characters are rejected with an error string (not thrown). Parse and\n * evaluation errors are also returned as error strings — the tool surfaces math errors as\n * content rather than exceptions, so the model can react to them in-line.\n */\nexport const calculateTool = new Tool({\n  name: 'calculate',\n  description:\n    'Evaluate a math expression. Supports arithmetic, trig, log, sqrt, factorial, matrices.',\n  inputSchema: validator.object({\n    expression: validator.string().required().description('Math expression, e.g. \"sin(pi/4) + 5!\"'),\n  }),\n  handler: async (args) => {\n    const { expression } = args as { expression: string }\n\n    const lengthError = validateExpression(expression)\n    if (lengthError) return lengthError\n\n    try {\n      const result = math.evaluate!(expression)\n      const node = math.parse!(expression)\n      const katex = node.toTex()\n      return `Result: ${result}\\nKaTeX: $${katex} = ${result}$`\n    } catch (err) {\n      return `Error: ${isError(err) ? err.message : String(err)}`\n    }\n  },\n})\n\n/**\n * Translates a LaTeX/KaTeX expression into mathjs syntax, evaluates it, and returns the result.\n *\n * @remarks\n * Translates common LaTeX constructs (`\\frac{a}{b}`, `\\sqrt{...}`, `\\cdot`, `\\times`, Greek\n * macros like `\\pi`, `\\left`/`\\right` delimiters, `\\text{...}`, subscripts, etc.) into their\n * mathjs equivalents before evaluation. Both the source and the translated mathjs expression\n * are subject to the 1000-character length cap.\n *\n * Parse and evaluation errors are returned as error strings rather than thrown.\n */\nexport const evaluateKatexTool = new Tool({\n  name: 'evaluate_katex',\n  description: 'Evaluate a KaTeX/LaTeX math expression and return the numeric result.',\n  inputSchema: validator.object({\n    katex: validator\n      .string()\n      .required()\n      .description('LaTeX expression, e.g. \"\\\\frac{1}{2} + \\\\sqrt{9}\"'),\n  }),\n  handler: async (args) => {\n    const { katex } = args as { katex: string }\n\n    const lengthError = validateExpression(katex)\n    if (lengthError) return lengthError\n\n    try {\n      const mathjsExpr = latexToMathjs(katex)\n\n      const translatedLengthError = validateExpression(mathjsExpr)\n      if (translatedLengthError) return translatedLengthError\n\n      const result = math.evaluate!(mathjsExpr)\n      return `Converted: ${mathjsExpr}\\nResult: ${result}`\n    } catch (err) {\n      return `Error: ${isError(err) ? err.message : String(err)}`\n    }\n  },\n})\n"],"mappings":";;;;;;;;;;;;;;;;;;AAeA,IAAM,QAAA,GAAA,OAAA,QAAc,OAAA,GAAG;AAavB,KAAK,MAAM,MAAM;CAVf;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AAGe,GACf,IAAI,MAAM,MACP,KAAc,MAAM,KAAA;AAIzB,IAAM,wBAAwB;AAE9B,SAAS,mBAAmB,MAAkC;CAC5D,IAAI,KAAK,SAAS,uBAChB,OAAO,4BAA4B,sBAAsB;AAG7D;;;;AAKA,SAAS,cAAc,OAAuB;CAC5C,IAAI,OAAO,MAAM,KAAK;CAEtB,OAAO,KAAK,QAAQ,kBAAkB,EAAE;CACxC,OAAO,KAAK,QAAQ,qBAAqB,EAAE;CAE3C,KAAK,IAAI,IAAI,GAAG,IAAI,IAAI,KAAK;EAC3B,MAAM,SAAS;EACf,OAAO,KAAK,QAAQ,yCAAyC,aAAa;EAC1E,IAAI,SAAS,QAAQ;CACvB;CAEA,OAAO,KAAK,QAAQ,sCAAsC,iBAAiB;CAC3E,OAAO,KAAK,QAAQ,0BAA0B,UAAU;CAExD,OAAO,KAAK,QACV,uFACA,IACF;CAEA,OAAO,KAAK,QAAQ,kCAAkC,aAAa;CACnE,OAAO,KAAK,QAAQ,iBAAiB,OAAO;CAC5C,OAAO,KAAK,QAAQ,gBAAgB,EAAE;CACtC,OAAO,KAAK,QAAQ,QAAQ,EAAE;CAE9B,OAAO,KAAK,QAAQ,SAAS,IAAI;CACjC,OAAO,KAAK,QACV,2EACA,IACF;CAEA,OAAO,KAAK,QAAQ,WAAW,GAAG;CAClC,OAAO,KAAK,QAAQ,YAAY,GAAG;CACnC,OAAO,KAAK,QAAQ,UAAU,GAAG;CACjC,OAAO,KAAK,QAAQ,YAAY,UAAU;CAC1C,OAAO,KAAK,QAAQ,sBAAsB,IAAI;CAC9C,OAAO,KAAK,QAAQ,wBAAwB,IAAI;CAChD,OAAO,KAAK,QAAQ,UAAU,KAAK;CACnC,OAAO,KAAK,QAAQ,WAAW,MAAM;CACrC,OAAO,KAAK,QAAQ,QAAQ,GAAG;CAC/B,OAAO,KAAK,QAAQ,QAAQ,GAAG;CAC/B,OAAO,KAAK,QAAQ,WAAW,GAAG;CAClC,OAAO,KAAK,QAAQ,YAAY,GAAG;CACnC,OAAO,KAAK,QAAQ,uBAAuB,EAAE;CAC7C,OAAO,KAAK,QAAQ,oBAAoB,OAAO;CAC/C,OAAO,KAAK,QAAQ,YAAY,KAAK;CACrC,OAAO,KAAK,QAAQ,QAAQ,GAAG,EAAE,KAAK;CAEtC,OAAO;AACT;;;;;;;;;;;;;;;AAgBA,IAAa,gBAAgB,IAAI,aAAA,KAAK;CACpC,MAAM;CACN,aACE;CACF,aAAa,kBAAA,UAAU,OAAO,EAC5B,YAAY,kBAAA,UAAU,OAAO,EAAE,SAAS,EAAE,YAAY,0CAAwC,EAChG,CAAC;CACD,SAAS,OAAO,SAAS;EACvB,MAAM,EAAE,eAAe;EAEvB,MAAM,cAAc,mBAAmB,UAAU;EACjD,IAAI,aAAa,OAAO;EAExB,IAAI;GACF,MAAM,SAAS,KAAK,SAAU,UAAU;GAGxC,OAAO,WAAW,OAAO,YAFZ,KAAK,MAAO,UACX,EAAK,MACkB,EAAM,KAAK,OAAO;EACzD,SAAS,KAAK;GACZ,OAAO,UAAU,sBAAA,QAAQ,GAAG,IAAI,IAAI,UAAU,OAAO,GAAG;EAC1D;CACF;AACF,CAAC;;;;;;;;;;;;AAaD,IAAa,oBAAoB,IAAI,aAAA,KAAK;CACxC,MAAM;CACN,aAAa;CACb,aAAa,kBAAA,UAAU,OAAO,EAC5B,OAAO,kBAAA,UACJ,OAAO,EACP,SAAS,EACT,YAAY,qDAAmD,EACpE,CAAC;CACD,SAAS,OAAO,SAAS;EACvB,MAAM,EAAE,UAAU;EAElB,MAAM,cAAc,mBAAmB,KAAK;EAC5C,IAAI,aAAa,OAAO;EAExB,IAAI;GACF,MAAM,aAAa,cAAc,KAAK;GAEtC,MAAM,wBAAwB,mBAAmB,UAAU;GAC3D,IAAI,uBAAuB,OAAO;GAGlC,OAAO,cAAc,WAAW,YADjB,KAAK,SAAU,UACc;EAC9C,SAAS,KAAK;GACZ,OAAO,UAAU,sBAAA,QAAQ,GAAG,IAAI,IAAI,UAAU,OAAO,GAAG;EAC1D;CACF;AACF,CAAC"}

package/batteries/tools/math.mjs

@@ -0,0 +1,133 @@
+import { o as isError } from "../../tool_registry-DqLOyGyG.mjs";
+import "../../common-DeZaonK1.mjs";
+import { t as Tool } from "../../tool-D2WB1EA1.mjs";
+import "../../guards.mjs";
+import { validator } from "@nhtio/validation";
+import { all, create } from "mathjs";
+//#region src/batteries/tools/math/index.ts
+/**
+* Pre-constructed tools for safe arithmetic, expression evaluation, and numeric operations.
+*
+* @module @nhtio/adk/batteries/tools/math
+*
+* @remarks
+* Pre-constructed bundled tools for the `math` category. Import individually, the whole
+* category, or import every tool via `@nhtio/adk/batteries`.
+*/
+var math = create(all);
+for (const fn of [
+	"import",
+	"createUnit",
+	"simplify",
+	"derivative",
+	"compile",
+	"chain",
+	"reviver",
+	"replacer"
+]) if (fn in math) math[fn] = void 0;
+var MAX_EXPRESSION_LENGTH = 1e3;
+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.
+*/
+function latexToMathjs(latex) {
+	let expr = latex.trim();
+	expr = expr.replace(/^\$\$?|\$\$?$/g, "");
+	expr = expr.replace(/^\\[[(]|\\[\])]$/g, "");
+	for (let i = 0; i < 10; 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(/\\(sin|cos|tan|cot|sec|csc|arcsin|arccos|arctan|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, "");
+	expr = expr.replace(/_\w/g, "");
+	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();
+	return expr;
+}
+/**
+* Evaluates a mathjs-syntax expression and returns the numeric result alongside the KaTeX
+* representation of the parsed expression.
+*
+* @remarks
+* Supports arithmetic, trigonometric, logarithmic, exponential, factorial, matrix, and unit
+* operations via `mathjs`. The mathjs instance is hardened: dangerous functions (`import`,
+* `createUnit`, `simplify`, `derivative`, `compile`, `chain`, `reviver`, `replacer`) are
+* disabled to prevent interpreter-surface exposure.
+*
+* Expressions over 1000 characters are rejected with an error string (not thrown). Parse and
+* evaluation errors are also returned as error strings — the tool surfaces math errors as
+* content rather than exceptions, so the model can react to them in-line.
+*/
+var calculateTool = new Tool({
+	name: "calculate",
+	description: "Evaluate a math expression. Supports arithmetic, trig, log, sqrt, factorial, matrices.",
+	inputSchema: validator.object({ expression: validator.string().required().description("Math expression, e.g. \"sin(pi/4) + 5!\"") }),
+	handler: async (args) => {
+		const { expression } = args;
+		const lengthError = validateExpression(expression);
+		if (lengthError) return lengthError;
+		try {
+			const result = math.evaluate(expression);
+			return `Result: ${result}\nKaTeX: $${math.parse(expression).toTex()} = ${result}$`;
+		} catch (err) {
+			return `Error: ${isError(err) ? err.message : String(err)}`;
+		}
+	}
+});
+/**
+* Translates a LaTeX/KaTeX expression into mathjs syntax, evaluates it, and returns the 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.
+*
+* Parse and evaluation errors are returned as error strings rather than thrown.
+*/
+var evaluateKatexTool = new Tool({
+	name: "evaluate_katex",
+	description: "Evaluate a KaTeX/LaTeX math expression and return the numeric result.",
+	inputSchema: validator.object({ katex: validator.string().required().description("LaTeX expression, e.g. \"\\frac{1}{2} + \\sqrt{9}\"") }),
+	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)}`;
+		} catch (err) {
+			return `Error: ${isError(err) ? err.message : String(err)}`;
+		}
+	}
+});
+//#endregion
+export { calculateTool, evaluateKatexTool };
+
+//# sourceMappingURL=math.mjs.map

package/batteries/tools/math.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"math.mjs","names":[],"sources":["../../../src/batteries/tools/math/index.ts"],"sourcesContent":["/**\n * Pre-constructed tools for safe arithmetic, expression evaluation, and numeric operations.\n *\n * @module @nhtio/adk/batteries/tools/math\n *\n * @remarks\n * Pre-constructed bundled tools for the `math` category. Import individually, the whole\n * category, or import every tool via `@nhtio/adk/batteries`.\n */\n\nimport { create, all } from 'mathjs'\nimport { Tool } from '@nhtio/adk/common'\nimport { isError } from '@nhtio/adk/guards'\nimport { validator } from '@nhtio/validation'\n\nconst math = create(all)\n\nconst BLOCKED_FUNCTIONS = [\n  'import',\n  'createUnit',\n  'simplify',\n  'derivative',\n  'compile',\n  'chain',\n  'reviver',\n  'replacer',\n]\n\nfor (const fn of BLOCKED_FUNCTIONS) {\n  if (fn in math) {\n    ;(math as any)[fn] = undefined\n  }\n}\n\nconst MAX_EXPRESSION_LENGTH = 1000\n\nfunction validateExpression(expr: string): string | undefined {\n  if (expr.length > MAX_EXPRESSION_LENGTH) {\n    return `Expression too long (max ${MAX_EXPRESSION_LENGTH} characters).`\n  }\n  return undefined\n}\n\n/**\n * Convert common LaTeX/KaTeX notation to a mathjs-evaluable expression.\n */\nfunction latexToMathjs(latex: string): string {\n  let expr = latex.trim()\n\n  expr = expr.replace(/^\\$\\$?|\\$\\$?$/g, '')\n  expr = expr.replace(/^\\\\[[(]|\\\\[\\])]$/g, '')\n\n  for (let i = 0; i < 10; i++) {\n    const before = expr\n    expr = expr.replace(/\\\\frac\\s*\\{([^{}]*)\\}\\s*\\{([^{}]*)\\}/g, '(($1)/($2))')\n    if (expr === before) break\n  }\n\n  expr = expr.replace(/\\\\sqrt\\[([^\\]]+)\\]\\s*\\{([^{}]*)\\}/g, 'nthRoot($2, $1)')\n  expr = expr.replace(/\\\\sqrt\\s*\\{([^{}]*)\\}/g, 'sqrt($1)')\n\n  expr = expr.replace(\n    /\\\\(sin|cos|tan|cot|sec|csc|arcsin|arccos|arctan|sinh|cosh|tanh|ln|log|exp|abs|det)/g,\n    '$1'\n  )\n\n  expr = expr.replace(/log_\\{?(\\w+)\\}?\\s*\\(([^)]+)\\)/g, 'log($2, $1)')\n  expr = expr.replace(/\\^{([^{}]*)}/g, '^($1)')\n  expr = expr.replace(/_\\{[^{}]*\\}/g, '')\n  expr = expr.replace(/_\\w/g, '')\n\n  expr = expr.replace(/\\\\pi/g, 'pi')\n  expr = expr.replace(\n    /\\\\(alpha|beta|gamma|delta|epsilon|theta|lambda|mu|sigma|tau|phi|omega)/g,\n    '$1'\n  )\n\n  expr = expr.replace(/\\\\cdot/g, '*')\n  expr = expr.replace(/\\\\times/g, '*')\n  expr = expr.replace(/\\\\div/g, '/')\n  expr = expr.replace(/\\\\infty/g, 'Infinity')\n  expr = expr.replace(/\\\\left\\s*([([{|])/g, '$1')\n  expr = expr.replace(/\\\\right\\s*([)\\]}|])/g, '$1')\n  expr = expr.replace(/\\\\sum/g, 'sum')\n  expr = expr.replace(/\\\\prod/g, 'prod')\n  expr = expr.replace(/\\\\,/g, ' ')\n  expr = expr.replace(/\\\\;/g, ' ')\n  expr = expr.replace(/\\\\quad/g, ' ')\n  expr = expr.replace(/\\\\qquad/g, ' ')\n  expr = expr.replace(/\\\\text\\{([^{}]*)\\}/g, '')\n  expr = expr.replace(/(\\d)([a-zA-Z(])/g, '$1*$2')\n  expr = expr.replace(/\\)\\s*\\(/g, ')*(')\n  expr = expr.replace(/\\s+/g, ' ').trim()\n\n  return expr\n}\n\n/**\n * Evaluates a mathjs-syntax expression and returns the numeric result alongside the KaTeX\n * representation of the parsed expression.\n *\n * @remarks\n * Supports arithmetic, trigonometric, logarithmic, exponential, factorial, matrix, and unit\n * operations via `mathjs`. The mathjs instance is hardened: dangerous functions (`import`,\n * `createUnit`, `simplify`, `derivative`, `compile`, `chain`, `reviver`, `replacer`) are\n * disabled to prevent interpreter-surface exposure.\n *\n * Expressions over 1000 characters are rejected with an error string (not thrown). Parse and\n * evaluation errors are also returned as error strings — the tool surfaces math errors as\n * content rather than exceptions, so the model can react to them in-line.\n */\nexport const calculateTool = new Tool({\n  name: 'calculate',\n  description:\n    'Evaluate a math expression. Supports arithmetic, trig, log, sqrt, factorial, matrices.',\n  inputSchema: validator.object({\n    expression: validator.string().required().description('Math expression, e.g. \"sin(pi/4) + 5!\"'),\n  }),\n  handler: async (args) => {\n    const { expression } = args as { expression: string }\n\n    const lengthError = validateExpression(expression)\n    if (lengthError) return lengthError\n\n    try {\n      const result = math.evaluate!(expression)\n      const node = math.parse!(expression)\n      const katex = node.toTex()\n      return `Result: ${result}\\nKaTeX: $${katex} = ${result}$`\n    } catch (err) {\n      return `Error: ${isError(err) ? err.message : String(err)}`\n    }\n  },\n})\n\n/**\n * Translates a LaTeX/KaTeX expression into mathjs syntax, evaluates it, and returns the result.\n *\n * @remarks\n * Translates common LaTeX constructs (`\\frac{a}{b}`, `\\sqrt{...}`, `\\cdot`, `\\times`, Greek\n * macros like `\\pi`, `\\left`/`\\right` delimiters, `\\text{...}`, subscripts, etc.) into their\n * mathjs equivalents before evaluation. Both the source and the translated mathjs expression\n * are subject to the 1000-character length cap.\n *\n * Parse and evaluation errors are returned as error strings rather than thrown.\n */\nexport const evaluateKatexTool = new Tool({\n  name: 'evaluate_katex',\n  description: 'Evaluate a KaTeX/LaTeX math expression and return the numeric result.',\n  inputSchema: validator.object({\n    katex: validator\n      .string()\n      .required()\n      .description('LaTeX expression, e.g. \"\\\\frac{1}{2} + \\\\sqrt{9}\"'),\n  }),\n  handler: async (args) => {\n    const { katex } = args as { katex: string }\n\n    const lengthError = validateExpression(katex)\n    if (lengthError) return lengthError\n\n    try {\n      const mathjsExpr = latexToMathjs(katex)\n\n      const translatedLengthError = validateExpression(mathjsExpr)\n      if (translatedLengthError) return translatedLengthError\n\n      const result = math.evaluate!(mathjsExpr)\n      return `Converted: ${mathjsExpr}\\nResult: ${result}`\n    } catch (err) {\n      return `Error: ${isError(err) ? err.message : String(err)}`\n    }\n  },\n})\n"],"mappings":";;;;;;;;;;;;;;;;AAeA,IAAM,OAAO,OAAO,GAAG;AAavB,KAAK,MAAM,MAAM;CAVf;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AAGe,GACf,IAAI,MAAM,MACP,KAAc,MAAM,KAAA;AAIzB,IAAM,wBAAwB;AAE9B,SAAS,mBAAmB,MAAkC;CAC5D,IAAI,KAAK,SAAS,uBAChB,OAAO,4BAA4B,sBAAsB;AAG7D;;;;AAKA,SAAS,cAAc,OAAuB;CAC5C,IAAI,OAAO,MAAM,KAAK;CAEtB,OAAO,KAAK,QAAQ,kBAAkB,EAAE;CACxC,OAAO,KAAK,QAAQ,qBAAqB,EAAE;CAE3C,KAAK,IAAI,IAAI,GAAG,IAAI,IAAI,KAAK;EAC3B,MAAM,SAAS;EACf,OAAO,KAAK,QAAQ,yCAAyC,aAAa;EAC1E,IAAI,SAAS,QAAQ;CACvB;CAEA,OAAO,KAAK,QAAQ,sCAAsC,iBAAiB;CAC3E,OAAO,KAAK,QAAQ,0BAA0B,UAAU;CAExD,OAAO,KAAK,QACV,uFACA,IACF;CAEA,OAAO,KAAK,QAAQ,kCAAkC,aAAa;CACnE,OAAO,KAAK,QAAQ,iBAAiB,OAAO;CAC5C,OAAO,KAAK,QAAQ,gBAAgB,EAAE;CACtC,OAAO,KAAK,QAAQ,QAAQ,EAAE;CAE9B,OAAO,KAAK,QAAQ,SAAS,IAAI;CACjC,OAAO,KAAK,QACV,2EACA,IACF;CAEA,OAAO,KAAK,QAAQ,WAAW,GAAG;CAClC,OAAO,KAAK,QAAQ,YAAY,GAAG;CACnC,OAAO,KAAK,QAAQ,UAAU,GAAG;CACjC,OAAO,KAAK,QAAQ,YAAY,UAAU;CAC1C,OAAO,KAAK,QAAQ,sBAAsB,IAAI;CAC9C,OAAO,KAAK,QAAQ,wBAAwB,IAAI;CAChD,OAAO,KAAK,QAAQ,UAAU,KAAK;CACnC,OAAO,KAAK,QAAQ,WAAW,MAAM;CACrC,OAAO,KAAK,QAAQ,QAAQ,GAAG;CAC/B,OAAO,KAAK,QAAQ,QAAQ,GAAG;CAC/B,OAAO,KAAK,QAAQ,WAAW,GAAG;CAClC,OAAO,KAAK,QAAQ,YAAY,GAAG;CACnC,OAAO,KAAK,QAAQ,uBAAuB,EAAE;CAC7C,OAAO,KAAK,QAAQ,oBAAoB,OAAO;CAC/C,OAAO,KAAK,QAAQ,YAAY,KAAK;CACrC,OAAO,KAAK,QAAQ,QAAQ,GAAG,EAAE,KAAK;CAEtC,OAAO;AACT;;;;;;;;;;;;;;;AAgBA,IAAa,gBAAgB,IAAI,KAAK;CACpC,MAAM;CACN,aACE;CACF,aAAa,UAAU,OAAO,EAC5B,YAAY,UAAU,OAAO,EAAE,SAAS,EAAE,YAAY,0CAAwC,EAChG,CAAC;CACD,SAAS,OAAO,SAAS;EACvB,MAAM,EAAE,eAAe;EAEvB,MAAM,cAAc,mBAAmB,UAAU;EACjD,IAAI,aAAa,OAAO;EAExB,IAAI;GACF,MAAM,SAAS,KAAK,SAAU,UAAU;GAGxC,OAAO,WAAW,OAAO,YAFZ,KAAK,MAAO,UACX,EAAK,MACkB,EAAM,KAAK,OAAO;EACzD,SAAS,KAAK;GACZ,OAAO,UAAU,QAAQ,GAAG,IAAI,IAAI,UAAU,OAAO,GAAG;EAC1D;CACF;AACF,CAAC;;;;;;;;;;;;AAaD,IAAa,oBAAoB,IAAI,KAAK;CACxC,MAAM;CACN,aAAa;CACb,aAAa,UAAU,OAAO,EAC5B,OAAO,UACJ,OAAO,EACP,SAAS,EACT,YAAY,qDAAmD,EACpE,CAAC;CACD,SAAS,OAAO,SAAS;EACvB,MAAM,EAAE,UAAU;EAElB,MAAM,cAAc,mBAAmB,KAAK;EAC5C,IAAI,aAAa,OAAO;EAExB,IAAI;GACF,MAAM,aAAa,cAAc,KAAK;GAEtC,MAAM,wBAAwB,mBAAmB,UAAU;GAC3D,IAAI,uBAAuB,OAAO;GAGlC,OAAO,cAAc,WAAW,YADjB,KAAK,SAAU,UACc;EAC9C,SAAS,KAAK;GACZ,OAAO,UAAU,QAAQ,GAAG,IAAI,IAAI,UAAU,OAAO,GAAG;EAC1D;CACF;AACF,CAAC"}

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

@@ -0,0 +1,73 @@
+/**
+ * Pre-constructed CRUD tools for model-visible ADK memory management.
+ *
+ * @module @nhtio/adk/batteries/tools/memory
+ *
+ * @remarks
+ * Pre-constructed CRUD tools that expose the ADK's {@link @nhtio/adk!Memory} surface to the model.
+ * Each tool delegates to the corresponding callback on the active {@link @nhtio/adk!DispatchContext}
+ * (`fetchMemories`, `storeMemory`, `mutateMemory`, `deleteMemory`) — the persistence layer is
+ * whatever the consumer wired into the runner.
+ *
+ * Memory entries carry agent-internal `confidence` / `importance` scores and are rendered
+ * through the LLM battery's recall-tier envelope. Letting the model author and curate its own
+ * memories is the canonical use case for these tools; deployers who do not want the model to
+ * mutate memory should simply not register the relevant tools.
+ *
+ * Output is JSON for every tool so consumers can parse the result without re-tokenising — the
+ * artifact constructor is set to {@link @nhtio/adk!SpooledJsonArtifact}.
+ *
+ * Tools:
+ * - {@link listMemoriesTool} — read-only list of every memory currently held by the context.
+ * - {@link storeMemoryTool} — create a new memory (auto-generates `id` / `createdAt` /
+ *   `updatedAt` unless explicit values are supplied).
+ * - {@link updateMemoryTool} — replace an existing memory by `id`. Bumps `updatedAt`.
+ * - {@link deleteMemoryTool} — remove a memory by `id`.
+ */
+import { SpooledJsonArtifact, Tool } from "../../../common";
+/**
+ * List every memory currently held by the active execution context.
+ *
+ * @remarks
+ * Delegates to `ctx.fetchMemories()`. Returns a JSON-encoded array of memory records (id,
+ * content, confidence, importance, createdAt, updatedAt). The model can use the `id` values
+ * to drive subsequent `update_memory` / `delete_memory` calls.
+ */
+export declare const listMemoriesTool: Tool<SpooledJsonArtifact<unknown>>;
+/**
+ * Create a new {@link @nhtio/adk!Memory} record and persist it via the context's `storeMemory` callback.
+ *
+ * @remarks
+ * When `id` is omitted, a UUID v6 is generated. When `createdAt` / `updatedAt` are omitted,
+ * the current time is used. The model authors `content`, `confidence`, and `importance`
+ * directly. The resulting record is added to `ctx.turnMemories` and flushed to the consumer's
+ * persistence layer.
+ */
+export declare const storeMemoryTool: Tool<SpooledJsonArtifact<unknown>>;
+/**
+ * Replace an existing {@link @nhtio/adk!Memory} by `id`.
+ *
+ * @remarks
+ * The model supplies `id` plus any subset of `content` / `confidence` / `importance`; fields
+ * left undefined retain their prior values. `updatedAt` is always bumped to the current time;
+ * `createdAt` is preserved. Returns an error when no memory with the supplied `id` is found.
+ */
+export declare const updateMemoryTool: Tool<SpooledJsonArtifact<unknown>>;
+/**
+ * Remove an existing {@link @nhtio/adk!Memory} by `id`.
+ *
+ * @remarks
+ * Delegates to `ctx.deleteMemory(id)`. Returns `{ ok: true, id }` on success regardless of
+ * whether a memory was actually present — `deleteMemory` is idempotent at the ADK level.
+ */
+export declare const deleteMemoryTool: Tool<SpooledJsonArtifact<unknown>>;
+/**
+ * Convenience tuple of every memory CRUD tool. Spread into a {@link @nhtio/adk!ToolRegistry} to register
+ * the entire category at once: `registry.register(...memoryTools)`.
+ */
+export declare const memoryTools: readonly [
+    Tool<SpooledJsonArtifact<unknown>>,
+    Tool<SpooledJsonArtifact<unknown>>,
+    Tool<SpooledJsonArtifact<unknown>>,
+    Tool<SpooledJsonArtifact<unknown>>
+];

package/batteries/tools/memory.cjs

@@ -0,0 +1,193 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("../../chunk-KmRHZBOW.js");
+const require_tool_registry = require("../../tool_registry-Dkfprsck.js");
+const require_thought = require("../../thought-DuN2PgdO.js");
+require("../../common-Od8edUXU.js");
+const require_tool = require("../../tool-COSeH8I6.js");
+const require_spooled_markdown_artifact = require("../../spooled_markdown_artifact-RRB113sy.js");
+require("../../guards.cjs");
+let _nhtio_validation = require("@nhtio/validation");
+let uuid = require("uuid");
+let luxon = require("luxon");
+//#region src/batteries/tools/memory/index.ts
+/**
+* Pre-constructed CRUD tools for model-visible ADK memory management.
+*
+* @module @nhtio/adk/batteries/tools/memory
+*
+* @remarks
+* Pre-constructed CRUD tools that expose the ADK's {@link @nhtio/adk!Memory} surface to the model.
+* Each tool delegates to the corresponding callback on the active {@link @nhtio/adk!DispatchContext}
+* (`fetchMemories`, `storeMemory`, `mutateMemory`, `deleteMemory`) — the persistence layer is
+* whatever the consumer wired into the runner.
+*
+* Memory entries carry agent-internal `confidence` / `importance` scores and are rendered
+* through the LLM battery's recall-tier envelope. Letting the model author and curate its own
+* memories is the canonical use case for these tools; deployers who do not want the model to
+* mutate memory should simply not register the relevant tools.
+*
+* Output is JSON for every tool so consumers can parse the result without re-tokenising — the
+* artifact constructor is set to {@link @nhtio/adk!SpooledJsonArtifact}.
+*
+* Tools:
+* - {@link listMemoriesTool} — read-only list of every memory currently held by the context.
+* - {@link storeMemoryTool} — create a new memory (auto-generates `id` / `createdAt` /
+*   `updatedAt` unless explicit values are supplied).
+* - {@link updateMemoryTool} — replace an existing memory by `id`. Bumps `updatedAt`.
+* - {@link deleteMemoryTool} — remove a memory by `id`.
+*/
+var serialiseMemory = (m) => ({
+	id: m.id,
+	content: m.content.toString(),
+	confidence: m.confidence,
+	importance: m.importance,
+	createdAt: m.createdAt.toISO(),
+	updatedAt: m.updatedAt.toISO()
+});
+/**
+* List every memory currently held by the active execution context.
+*
+* @remarks
+* Delegates to `ctx.fetchMemories()`. Returns a JSON-encoded array of memory records (id,
+* content, confidence, importance, createdAt, updatedAt). The model can use the `id` values
+* to drive subsequent `update_memory` / `delete_memory` calls.
+*/
+var listMemoriesTool = new require_tool.Tool({
+	name: "list_memories",
+	description: "List every memory currently held by the agent. Returns a JSON array of memory records with id, content, confidence, importance, createdAt, and updatedAt.",
+	inputSchema: _nhtio_validation.validator.object({}),
+	artifactConstructor: () => require_spooled_markdown_artifact.SpooledJsonArtifact,
+	handler: async (_args, ctx) => {
+		try {
+			const memories = await ctx.fetchMemories();
+			return JSON.stringify(memories.map(serialiseMemory), null, 2);
+		} catch (err) {
+			return `Error: ${require_tool_registry.isError(err) ? err.message : String(err)}`;
+		}
+	}
+});
+/**
+* Create a new {@link @nhtio/adk!Memory} record and persist it via the context's `storeMemory` callback.
+*
+* @remarks
+* When `id` is omitted, a UUID v6 is generated. When `createdAt` / `updatedAt` are omitted,
+* the current time is used. The model authors `content`, `confidence`, and `importance`
+* directly. The resulting record is added to `ctx.turnMemories` and flushed to the consumer's
+* persistence layer.
+*/
+var storeMemoryTool = new require_tool.Tool({
+	name: "store_memory",
+	description: "Store a new memory record. Provide the content, your confidence (0–1) that the memory is accurate, and the importance (0–1) of the memory for future recall. id and timestamps are auto-generated if omitted.",
+	inputSchema: _nhtio_validation.validator.object({
+		content: _nhtio_validation.validator.string().required().description("The memory content as a plain string."),
+		confidence: _nhtio_validation.validator.number().min(0).max(1).required().description("Confidence in [0, 1] that this memory is accurate."),
+		importance: _nhtio_validation.validator.number().min(0).max(1).required().description("Importance in [0, 1] — how much weight the memory should carry on recall."),
+		id: _nhtio_validation.validator.string().optional().description("Optional stable id. Auto-generated when absent.")
+	}),
+	artifactConstructor: () => require_spooled_markdown_artifact.SpooledJsonArtifact,
+	handler: async (args, ctx) => {
+		const { content, confidence, importance, id } = args;
+		try {
+			const now = luxon.DateTime.now();
+			const memory = new require_thought.Memory({
+				id: id ?? (0, uuid.v6)(),
+				content,
+				confidence,
+				importance,
+				createdAt: now,
+				updatedAt: now
+			});
+			await ctx.storeMemory(memory);
+			return JSON.stringify({
+				ok: true,
+				memory: serialiseMemory(memory)
+			}, null, 2);
+		} catch (err) {
+			return `Error: ${require_tool_registry.isError(err) ? err.message : String(err)}`;
+		}
+	}
+});
+/**
+* Replace an existing {@link @nhtio/adk!Memory} by `id`.
+*
+* @remarks
+* The model supplies `id` plus any subset of `content` / `confidence` / `importance`; fields
+* left undefined retain their prior values. `updatedAt` is always bumped to the current time;
+* `createdAt` is preserved. Returns an error when no memory with the supplied `id` is found.
+*/
+var updateMemoryTool = new require_tool.Tool({
+	name: "update_memory",
+	description: "Update an existing memory by id. Supply any subset of content / confidence / importance — omitted fields retain their prior values. updatedAt is always refreshed.",
+	inputSchema: _nhtio_validation.validator.object({
+		id: _nhtio_validation.validator.string().required().description("Id of the memory to update."),
+		content: _nhtio_validation.validator.string().optional().description("Replacement content."),
+		confidence: _nhtio_validation.validator.number().min(0).max(1).optional().description("Replacement confidence in [0, 1]."),
+		importance: _nhtio_validation.validator.number().min(0).max(1).optional().description("Replacement importance in [0, 1].")
+	}),
+	artifactConstructor: () => require_spooled_markdown_artifact.SpooledJsonArtifact,
+	handler: async (args, ctx) => {
+		const { id, content, confidence, importance } = args;
+		try {
+			const existing = (await ctx.fetchMemories()).find((m) => m.id === id);
+			if (!existing) return `Error: No memory found with id "${id}".`;
+			const updated = new require_thought.Memory({
+				id: existing.id,
+				content: content ?? existing.content,
+				confidence: confidence ?? existing.confidence,
+				importance: importance ?? existing.importance,
+				createdAt: existing.createdAt,
+				updatedAt: luxon.DateTime.now()
+			});
+			await ctx.mutateMemory(updated);
+			return JSON.stringify({
+				ok: true,
+				memory: serialiseMemory(updated)
+			}, null, 2);
+		} catch (err) {
+			return `Error: ${require_tool_registry.isError(err) ? err.message : String(err)}`;
+		}
+	}
+});
+/**
+* Remove an existing {@link @nhtio/adk!Memory} by `id`.
+*
+* @remarks
+* Delegates to `ctx.deleteMemory(id)`. Returns `{ ok: true, id }` on success regardless of
+* whether a memory was actually present — `deleteMemory` is idempotent at the ADK level.
+*/
+var deleteMemoryTool = new require_tool.Tool({
+	name: "delete_memory",
+	description: "Delete a memory by id.",
+	inputSchema: _nhtio_validation.validator.object({ id: _nhtio_validation.validator.string().required().description("Id of the memory to delete.") }),
+	artifactConstructor: () => require_spooled_markdown_artifact.SpooledJsonArtifact,
+	handler: async (args, ctx) => {
+		const { id } = args;
+		try {
+			await ctx.deleteMemory(id);
+			return JSON.stringify({
+				ok: true,
+				id
+			}, null, 2);
+		} catch (err) {
+			return `Error: ${require_tool_registry.isError(err) ? err.message : String(err)}`;
+		}
+	}
+});
+/**
+* Convenience tuple of every memory CRUD tool. Spread into a {@link @nhtio/adk!ToolRegistry} to register
+* the entire category at once: `registry.register(...memoryTools)`.
+*/
+var memoryTools = [
+	listMemoriesTool,
+	storeMemoryTool,
+	updateMemoryTool,
+	deleteMemoryTool
+];
+//#endregion
+exports.deleteMemoryTool = deleteMemoryTool;
+exports.listMemoriesTool = listMemoriesTool;
+exports.memoryTools = memoryTools;
+exports.storeMemoryTool = storeMemoryTool;
+exports.updateMemoryTool = updateMemoryTool;
+
+//# sourceMappingURL=memory.cjs.map