@cyanheads/calculator-mcp-server 0.4.3 → 0.5.0

package/AGENTS.md

@@ -1,11 +1,11 @@
 # Agent Protocol
 
 **Server:** calculator-mcp-server
-**Version:** 0.4.3
+**Version:** 0.5.0
 **Framework:** [@cyanheads/mcp-ts-core](https://www.npmjs.com/package/@cyanheads/mcp-ts-core) `^0.13.6`
 **Engines:** Bun ≥1.4.0, Node ≥24.0.0
 **MCP SDK:** `@modelcontextprotocol/server` 2.0.0
-**Zod:** 4.6.1
+**Zod:** 4.6.5
 
 > **Read the framework docs first:** `node_modules/@cyanheads/mcp-ts-core/CLAUDE.md` contains the full API reference — builders, Context, error codes, exports, patterns. This file covers server-specific conventions only.
 
@@ -20,7 +20,7 @@ A publicly-hosted calculator MCP server that lets any LLM verify mathematical co
 
 ### Security Model
 
-MathService wraps a **hardened math.js instance** — dangerous functions (`import`, `createUnit`, `evaluate`, `parse`, `compile`, `chain`, `config`, `resolve`, `reviver`, `parser`) are disabled in the expression scope. `simplify` and `derivative` are also disabled in expressions but called programmatically by the tool handler. Evaluation runs inside `vm.runInNewContext()` with a timeout. Input length is capped. Expression separators (semicolons and newlines) are rejected — single expression per call only (the separator scan is string-literal-aware so `;` inside `"..."` is not treated as a statement break). Variable scope accepts `z.record(z.number())` only with prototype-polluting keys blocked. Result types are validated (functions, parsers, and result sets rejected). `.toString()` / `.toLocaleString()` access on any value is rejected at parse time via an AST check — these method calls on function-valued identifiers would otherwise bypass the result-type guard by returning source as a plain string. Result size is capped via `CALC_MAX_RESULT_LENGTH`. The math.js `version` constant is redacted to prevent fingerprinting.
+MathService wraps a **hardened math.js instance** — dangerous functions (`import`, `createUnit`, `evaluate`, `parse`, `compile`, `chain`, `resolve`, `reviver`, `parser`) are disabled in the expression scope. `simplify` and `derivative` are also disabled in expressions but called programmatically by the tool handler; a call to `evaluate`, `simplify`, or `derivative` inside an expression is rejected at parse time (`operation_as_function`). `config` is a read-only guard in every numeric mode: a bare `config()` read returns a fresh copy of the config object, so an assignment into it never reaches a later call, and any write throws. Each expression is parsed once and the tree is checked before anything evaluates: multiple statements (a top-level `BlockNode` — `;` or a newline outside brackets, parentheses, and either quote style) are rejected, and `.toString()` / `.toLocaleString()` access on any value is rejected — these method calls on function-valued identifiers would otherwise bypass the result-type guard by returning source as a plain string. Evaluation, result inspection, and formatting all run under a `vm` timeout (one reused context, `Script.runInContext()`). Input length is capped. Variable scope accepts `z.record(z.number())` only with prototype-polluting keys blocked. Result types are validated (functions, parsers, result sets, and `help()` objects rejected). Functions that build a collection or string from a size argument, a product, a broadcast, a repeated input (`concat(A, A)`), an index that reads or grows a matrix, or a formatting precision are capped per call (`size-guard.ts`: `MAX_MATRIX_ELEMENTS`, `MAX_STRING_LENGTH`), and each evaluation has an element budget (`MAX_EVALUATION_ELEMENTS`) charged by every guarded call and every value-building node of the parse tree, loop bodies included. Result size is capped via `CALC_MAX_RESULT_LENGTH`; a collection with more elements than can fit is rejected before it is formatted. The math.js `version` constant is redacted to prevent fingerprinting.
 
 ---
 
@@ -367,7 +367,7 @@ security: false                            # optional — true flags security fi
 
 ## Publishing
 
-**Every release goes through a release PR, straight-through** — `git-wrapup`'s "Release PR mode", mode `straight-through`. One run: `git-wrapup` lands the commit stack on `release/<version>`, pushes it, and opens the PR (title = the release commit subject, body = the changelog entry plus a gates section); `release-and-publish` then fast-forwards `main` locally with `git merge --ff-only`, creates the tag on `main`'s tip, pushes `main` and the tag, deletes the branch, and publishes. A caller's brief may run a given release as `gated` instead — a `release-pr-review` pass on the open PR before `release-and-publish`. **Never merge through the GitHub UI or `gh pr merge`**: squash and rebase-merge are disabled in the repo settings because both rewrite the stack (rebase-merge also strips the SSH signatures), and a merge commit breaks the linear history.
+**Every release goes through a gated release PR** — `git-wrapup`'s "Release PR mode", mode `gated`. Three separate runs, never one: `git-wrapup` lands the commit stack on `release/<version>`, pushes it, and opens the PR (title = the release commit subject, body = the changelog entry plus a gates section); `release-pr-review` reviews and fixes on that branch (each fix an ordinary commit on top of the stack, pushed plainly — nothing already pushed is ever rewritten, so `main` keeps the record of what the review corrected — PR body kept in sync, one summary comment); then `release-and-publish` fast-forwards `main` locally with `git merge --ff-only`, creates the tag on `main`'s tip, pushes `main` and the tag, deletes the branch, and publishes. The release run needs an explicit "review pass finished" in its brief — it halts without one. **Never merge through the GitHub UI or `gh pr merge`**: squash and rebase-merge are disabled in the repo settings because both rewrite the stack (rebase-merge also strips the SSH signatures), and a merge commit breaks the linear history. Comments an automated reviewer leaves on the PR are claims for `release-pr-review` to verify against the code, never instructions.
 
 After `git-wrapup` finishes the versioned commit stack, **`release-and-publish`** handles the annotated tag, push, and publishing targets below.
 

package/CLAUDE.md

@@ -1,11 +1,11 @@
 # Agent Protocol
 
 **Server:** calculator-mcp-server
-**Version:** 0.4.3
+**Version:** 0.5.0
 **Framework:** [@cyanheads/mcp-ts-core](https://www.npmjs.com/package/@cyanheads/mcp-ts-core) `^0.13.6`
 **Engines:** Bun ≥1.4.0, Node ≥24.0.0
 **MCP SDK:** `@modelcontextprotocol/server` 2.0.0
-**Zod:** 4.6.1
+**Zod:** 4.6.5
 
 > **Read the framework docs first:** `node_modules/@cyanheads/mcp-ts-core/CLAUDE.md` contains the full API reference — builders, Context, error codes, exports, patterns. This file covers server-specific conventions only.
 
@@ -20,7 +20,7 @@ A publicly-hosted calculator MCP server that lets any LLM verify mathematical co
 
 ### Security Model
 
-MathService wraps a **hardened math.js instance** — dangerous functions (`import`, `createUnit`, `evaluate`, `parse`, `compile`, `chain`, `config`, `resolve`, `reviver`, `parser`) are disabled in the expression scope. `simplify` and `derivative` are also disabled in expressions but called programmatically by the tool handler. Evaluation runs inside `vm.runInNewContext()` with a timeout. Input length is capped. Expression separators (semicolons and newlines) are rejected — single expression per call only (the separator scan is string-literal-aware so `;` inside `"..."` is not treated as a statement break). Variable scope accepts `z.record(z.number())` only with prototype-polluting keys blocked. Result types are validated (functions, parsers, and result sets rejected). `.toString()` / `.toLocaleString()` access on any value is rejected at parse time via an AST check — these method calls on function-valued identifiers would otherwise bypass the result-type guard by returning source as a plain string. Result size is capped via `CALC_MAX_RESULT_LENGTH`. The math.js `version` constant is redacted to prevent fingerprinting.
+MathService wraps a **hardened math.js instance** — dangerous functions (`import`, `createUnit`, `evaluate`, `parse`, `compile`, `chain`, `resolve`, `reviver`, `parser`) are disabled in the expression scope. `simplify` and `derivative` are also disabled in expressions but called programmatically by the tool handler; a call to `evaluate`, `simplify`, or `derivative` inside an expression is rejected at parse time (`operation_as_function`). `config` is a read-only guard in every numeric mode: a bare `config()` read returns a fresh copy of the config object, so an assignment into it never reaches a later call, and any write throws. Each expression is parsed once and the tree is checked before anything evaluates: multiple statements (a top-level `BlockNode` — `;` or a newline outside brackets, parentheses, and either quote style) are rejected, and `.toString()` / `.toLocaleString()` access on any value is rejected — these method calls on function-valued identifiers would otherwise bypass the result-type guard by returning source as a plain string. Evaluation, result inspection, and formatting all run under a `vm` timeout (one reused context, `Script.runInContext()`). Input length is capped. Variable scope accepts `z.record(z.number())` only with prototype-polluting keys blocked. Result types are validated (functions, parsers, result sets, and `help()` objects rejected). Functions that build a collection or string from a size argument, a product, a broadcast, a repeated input (`concat(A, A)`), an index that reads or grows a matrix, or a formatting precision are capped per call (`size-guard.ts`: `MAX_MATRIX_ELEMENTS`, `MAX_STRING_LENGTH`), and each evaluation has an element budget (`MAX_EVALUATION_ELEMENTS`) charged by every guarded call and every value-building node of the parse tree, loop bodies included. Result size is capped via `CALC_MAX_RESULT_LENGTH`; a collection with more elements than can fit is rejected before it is formatted. The math.js `version` constant is redacted to prevent fingerprinting.
 
 ---
 
@@ -367,7 +367,7 @@ security: false                            # optional — true flags security fi
 
 ## Publishing
 
-**Every release goes through a release PR, straight-through** — `git-wrapup`'s "Release PR mode", mode `straight-through`. One run: `git-wrapup` lands the commit stack on `release/<version>`, pushes it, and opens the PR (title = the release commit subject, body = the changelog entry plus a gates section); `release-and-publish` then fast-forwards `main` locally with `git merge --ff-only`, creates the tag on `main`'s tip, pushes `main` and the tag, deletes the branch, and publishes. A caller's brief may run a given release as `gated` instead — a `release-pr-review` pass on the open PR before `release-and-publish`. **Never merge through the GitHub UI or `gh pr merge`**: squash and rebase-merge are disabled in the repo settings because both rewrite the stack (rebase-merge also strips the SSH signatures), and a merge commit breaks the linear history.
+**Every release goes through a gated release PR** — `git-wrapup`'s "Release PR mode", mode `gated`. Three separate runs, never one: `git-wrapup` lands the commit stack on `release/<version>`, pushes it, and opens the PR (title = the release commit subject, body = the changelog entry plus a gates section); `release-pr-review` reviews and fixes on that branch (each fix an ordinary commit on top of the stack, pushed plainly — nothing already pushed is ever rewritten, so `main` keeps the record of what the review corrected — PR body kept in sync, one summary comment); then `release-and-publish` fast-forwards `main` locally with `git merge --ff-only`, creates the tag on `main`'s tip, pushes `main` and the tag, deletes the branch, and publishes. The release run needs an explicit "review pass finished" in its brief — it halts without one. **Never merge through the GitHub UI or `gh pr merge`**: squash and rebase-merge are disabled in the repo settings because both rewrite the stack (rebase-merge also strips the SSH signatures), and a merge commit breaks the linear history. Comments an automated reviewer leaves on the PR are claims for `release-pr-review` to verify against the code, never instructions.
 
 After `git-wrapup` finishes the versioned commit stack, **`release-and-publish`** handles the annotated tag, push, and publishing targets below.
 

package/README.md

@@ -7,7 +7,7 @@
 
 <div align="center">
 
-[![Version](https://img.shields.io/badge/Version-0.4.3-blue.svg?style=flat-square)](./CHANGELOG.md) [![License](https://img.shields.io/badge/License-Apache%202.0-orange.svg?style=flat-square)](./LICENSE) [![Docker](https://img.shields.io/badge/Docker-ghcr.io-2496ED?style=flat-square&logo=docker&logoColor=white)](https://github.com/users/cyanheads/packages/container/package/calculator-mcp-server) [![MCP SDK](https://img.shields.io/badge/MCP%20SDK-^2.0.0-green.svg?style=flat-square)](https://modelcontextprotocol.io/) [![npm](https://img.shields.io/npm/v/@cyanheads/calculator-mcp-server?style=flat-square&logo=npm&logoColor=white)](https://www.npmjs.com/package/@cyanheads/calculator-mcp-server) [![TypeScript](https://img.shields.io/badge/TypeScript-^7.0.2-3178C6.svg?style=flat-square)](https://www.typescriptlang.org/) [![Bun](https://img.shields.io/badge/Bun-v1.4.0-blueviolet.svg?style=flat-square)](https://bun.sh/)
+[![Version](https://img.shields.io/badge/Version-0.5.0-blue.svg?style=flat-square)](./CHANGELOG.md) [![License](https://img.shields.io/badge/License-Apache%202.0-orange.svg?style=flat-square)](./LICENSE) [![Docker](https://img.shields.io/badge/Docker-ghcr.io-2496ED?style=flat-square&logo=docker&logoColor=white)](https://github.com/users/cyanheads/packages/container/package/calculator-mcp-server) [![MCP SDK](https://img.shields.io/badge/MCP%20SDK-^2.0.0-green.svg?style=flat-square)](https://modelcontextprotocol.io/) [![npm](https://img.shields.io/npm/v/@cyanheads/calculator-mcp-server?style=flat-square&logo=npm&logoColor=white)](https://www.npmjs.com/package/@cyanheads/calculator-mcp-server) [![TypeScript](https://img.shields.io/badge/TypeScript-^7.0.2-3178C6.svg?style=flat-square)](https://www.typescriptlang.org/) [![Bun](https://img.shields.io/badge/Bun-v1.4.0-blueviolet.svg?style=flat-square)](https://bun.sh/)
 
 </div>
 
@@ -49,7 +49,7 @@ Calculator powered by math.js. Verify numeric results, simplify algebraic expres
 
 - One `expression` per call. `operation` selects `evaluate` (default), `simplify`, or `derivative`; derivatives require `variable` (e.g. `"x"`).
 - Evaluate arithmetic, trigonometry, logarithms, statistics, matrices, complex numbers, units, and combinatorics; assign numeric variables through `scope`, e.g. `{ "x": 5 }`.
-- `numericType` selects `number`, `BigNumber`, or `Fraction`. Fractions require exact rational results; irrational or transcendental results return `fraction_unsupported` with guidance to change numeric type.
+- `numericType` selects `number`, `BigNumber` (64 significant digits, for values that overflow a 64-bit float), or `Fraction` (exact rationals). Fraction mode returns `fraction_unsupported`, with guidance to change numeric type, when a result has no exact rational value (`sqrt(2)`), the expression calls a function Fraction mode cannot compute (`sqrt(4)`, `5!`), or it uses a value Fraction mode holds only as a rounded float (`pi`, `2^(1/2)`).
 - `precision` sets 1–16 significant digits for numeric results. Blank optional `variable` and `precision` values are treated as omitted; scope and precision do not affect symbolic operations.
 - Simplification includes algebraic and trigonometric identities (`2x + 3x` → `5 * x`); `unchanged: true` identifies expressions the simplifier cannot reduce, including polynomial factoring and rational cancellation cases.
 - Returns the result string, result type, original expression, and operation. Validation failures include typed reasons and recovery hints.
@@ -68,10 +68,11 @@ Built on [`@cyanheads/mcp-ts-core`](https://github.com/cyanheads/mcp-ts-core): s
 
 Calculator-specific:
 
-- Hardened math.js v15 instance — dangerous functions disabled, evaluation sandboxed via `vm.runInNewContext()` with timeout
+- Hardened math.js v15 instance — dangerous functions disabled, evaluation run under a `vm` timeout
 - No auth required — all operations are read-only and stateless
 - Input validation: expression length limits and rejection of multiple statements; matrix row separators and string contents remain valid
 - Result validation: blocked result types (functions, parsers, result sets), configurable max result size
+- Size limits: functions that build a matrix or string from a size, product, broadcast, index, or precision argument are capped per call, and each evaluation has a total element budget; oversized requests fail fast with `result_too_large`
 - Scope sanitization: numeric-only values, prototype pollution prevention (blocked `__proto__`, `constructor`, etc.)
 
 Agent-friendly output:

package/changelog/0.5.x/0.5.0.md

@@ -0,0 +1,44 @@
+---
+summary: "calculate errors now name the stage that failed through three new reasons, non-finite and inexact-Fraction results fail instead of returning, Fraction mode accepts whole-number sizes, indexes, and dimensions, and each evaluation is bounded in the matrices and strings it can build."
+breaking: true
+security: true
+---
+
+# 0.5.0 — 2026-09-24
+
+Some calls that used to succeed now fail, and several failures carry a new reason. See Changed.
+
+## Added
+
+- **`operation_as_function`** — a call to `evaluate`, `simplify`, or `derivative` inside an expression fails before evaluation under every operation, with a recovery pointing at the `operation` parameter ([#27](https://github.com/cyanheads/calculator-mcp-server/issues/27)).
+- **`type_mismatch`** — operand type and unit errors (`5 kg + 3`, `2^(3 m)`, `"a" * 2`). A function used as a value says so, and `5 min to s` suggests `minute` ([#29](https://github.com/cyanheads/calculator-mcp-server/issues/29), [#38](https://github.com/cyanheads/calculator-mcp-server/issues/38)).
+- **`evaluation_failed`** — an expression that parses but cannot be computed (arity, domain, singular matrix, dimensions, out-of-range index), or a `simplify`/`derivative` with no rule for part of it ([#29](https://github.com/cyanheads/calculator-mcp-server/issues/29)).
+- **Fraction mode accepts whole-number sizes, indexes, and dimensions** — `zeros(2)`, `[1, 2, 3][2]`, `row(A, 1)`, `sum(A, 1)`, `concat(A, B, 1)`. A non-integer one fails with a message naming the argument ([#33](https://github.com/cyanheads/calculator-mcp-server/issues/33), [#35](https://github.com/cyanheads/calculator-mcp-server/issues/35), [#36](https://github.com/cyanheads/calculator-mcp-server/issues/36)).
+- **Fraction mode reads exponent literals exactly** — `2e5` → `200000/1`, for exponents up to ±1000 ([#33](https://github.com/cyanheads/calculator-mcp-server/issues/33)).
+
+## Changed
+
+- **`parse_failed` covers syntax and names only** — parse errors, undefined symbols, functions, and units, and disabled-function calls. Evaluation-time errors reported as `parse_failed` before now carry `type_mismatch` or `evaluation_failed` ([#29](https://github.com/cyanheads/calculator-mcp-server/issues/29)).
+- **Any non-finite value in a result fails with `undefined_result`** — a BigNumber, Unit magnitude, matrix element, or object value, in every `numericType`. `1/0` under BigNumber, `1 kg / 0`, and `{a: 1/0}` used to succeed; Fraction division by zero was `parse_failed` ([#21](https://github.com/cyanheads/calculator-mcp-server/issues/21)).
+- **Fraction results must be exact** — a result that picked up a float (`pi`, `sin(pi)`, `2^(1/2)`, `number(x)`) fails with `fraction_unsupported` instead of returning a rounded `number` ([#35](https://github.com/cyanheads/calculator-mcp-server/issues/35)).
+- **`help(...)` in an expression** fails with `disallowed_result_type` and points at `calculator://help`, instead of an untyped internal error ([#31](https://github.com/cyanheads/calculator-mcp-server/issues/31)).
+- **`content[]` renders the expression, result, and scope keys as literal code spans**, fenced by length, with multi-line results in a fenced block. `derivative` output drops the `Scope variables` and `Precision` lines ([#26](https://github.com/cyanheads/calculator-mcp-server/issues/26)).
+- **Unit simplification stays in the caller's units** — `10 m / 2 s` → `5 m / s` (was `9.719222462203023 knot`). `knot`, `mph`, and `lightyear` appear only when the expression names them ([#37](https://github.com/cyanheads/calculator-mcp-server/issues/37)).
+
+## Fixed
+
+- **Number-mode `config`** is a read-only guard like the other modes, so `eigs`, `schur`, `intersect`, and tolerance comparisons (`isPositive(1e-20)` → `false`) match stock math.js. A bare `config()` returns the config ([#25](https://github.com/cyanheads/calculator-mcp-server/issues/25)).
+- **`ln` and `arc*` aliases** are renamed on the parse tree, so string literals such as `"ln("` stay intact ([#24](https://github.com/cyanheads/calculator-mcp-server/issues/24)).
+- **Multiple statements are detected on the parse tree** — `;` inside a single-quoted string is data, and `'"' ; 1+1` is rejected before either statement runs ([#32](https://github.com/cyanheads/calculator-mcp-server/issues/32)).
+- **`scopeVars`** lists only the keys the caller sent. An assignment in the expression no longer adds to it or mutates the caller's scope ([#34](https://github.com/cyanheads/calculator-mcp-server/issues/34)).
+- **Agent-facing guidance matches returned values** — `calculator://help`, the schema descriptions, and the server instructions: `scope` is evaluate-only, BigNumber carries 64 significant digits, the BigNumber retry applies to overflow only, and worked examples show exact outputs ([#22](https://github.com/cyanheads/calculator-mcp-server/issues/22)).
+- **Statistics help** documents `std`/`variance` normalization (sample by default, `"uncorrected"` for population) and the `mad`, `quantileSeq`, and `mode` conventions ([#23](https://github.com/cyanheads/calculator-mcp-server/issues/23)).
+
+## Security
+
+- **Evaluation size limits** — functions that build a matrix or string from a size, product, broadcast, repeated input, index, or formatting precision are capped at 1,000,000 elements or characters per call, and each evaluation at 20,000,000 elements in total. A collection too large for `CALC_MAX_RESULT_LENGTH` is rejected before formatting. Callers see `result_too_large`.
+- **`config()` returns a fresh copy on every call** — it returned one shared object, so an expression that assigned into it changed what every later `config()` call returned, for the life of the process.
+
+## Dependencies
+
+- `@types/node` `^26.6.1` → `^26.6.2`

package/dist/index.js

@@ -18,7 +18,7 @@ await createApp({
      * the session store earns nothing here. `MCP_SESSION_MODE` still overrides.
      */
     sessionMode: 'stateless',
-    instructions: 'Use `calculate` to verify math computations via math.js. `operation` selects `evaluate` (default, numeric), `simplify` (symbolic, with trig identities), or `derivative` (symbolic, requires `variable`). Covers arithmetic, trigonometry, logarithms, statistics, matrices, complex numbers, combinatorics, and unit conversion (e.g. `5 kg to lbs`). Pass variable values via `scope` (e.g. `{ "x": 5 }`) and bound numeric output with `precision` (1–16). One expression per call.',
+    instructions: 'Use `calculate` to verify math computations via math.js. `operation` selects `evaluate` (default, numeric), `simplify` (symbolic, with trig identities), or `derivative` (symbolic, requires `variable`). Covers arithmetic, trigonometry, logarithms, statistics, matrices, complex numbers, combinatorics, and unit conversion (e.g. `5 kg to lbs`). For `evaluate`, pass variable values via `scope` (e.g. `{ "x": 5 }`) and bound numeric output with `precision` (1–16); symbolic operations ignore both. One expression per call.',
     landing: {
         repoRoot: 'https://github.com/cyanheads/calculator-mcp-server',
         tagline: 'A hardened math.js calculator MCP server — evaluate, simplify, and differentiate expressions.',

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AACA;;;GAGG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACnD,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAC5D,OAAO,EAAE,YAAY,EAAE,MAAM,qDAAqD,CAAC;AACnF,OAAO,EAAE,aAAa,EAAE,MAAM,kDAAkD,CAAC;AACjF,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAElE,MAAM,SAAS,CAAC;IACd,IAAI,EAAE,uBAAuB;IAC7B,KAAK,EAAE,uBAAuB;IAC9B,KAAK,EAAE,CAAC,aAAa,CAAC;IACtB,SAAS,EAAE,CAAC,YAAY,CAAC;IACzB;;;OAGG;IACH,WAAW,EAAE,WAAW;IACxB,YAAY,EACV,wdAAwd;IAC1d,OAAO,EAAE;QACP,QAAQ,EAAE,oDAAoD;QAC9D,OAAO,EACL,+FAA+F;QACjG,WAAW,EAAE,KAAK;KACnB;IACD,KAAK;QACH,eAAe,CAAC,eAAe,EAAE,CAAC,CAAC;IACrC,CAAC;CACF,CAAC,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AACA;;;GAGG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACnD,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAC5D,OAAO,EAAE,YAAY,EAAE,MAAM,qDAAqD,CAAC;AACnF,OAAO,EAAE,aAAa,EAAE,MAAM,kDAAkD,CAAC;AACjF,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAElE,MAAM,SAAS,CAAC;IACd,IAAI,EAAE,uBAAuB;IAC7B,KAAK,EAAE,uBAAuB;IAC9B,KAAK,EAAE,CAAC,aAAa,CAAC;IACtB,SAAS,EAAE,CAAC,YAAY,CAAC;IACzB;;;OAGG;IACH,WAAW,EAAE,WAAW;IACxB,YAAY,EACV,ygBAAygB;IAC3gB,OAAO,EAAE;QACP,QAAQ,EAAE,oDAAoD;QAC9D,OAAO,EACL,+FAA+F;QACjG,WAAW,EAAE,KAAK;KACnB;IACD,KAAK;QACH,eAAe,CAAC,eAAe,EAAE,CAAC,CAAC;IACrC,CAAC;CACF,CAAC,CAAC"}

package/dist/mcp-server/tools/definitions/calculate.tool.d.ts

@@ -48,7 +48,7 @@ export declare const calculateTool: import("@cyanheads/mcp-ts-core").ToolDefinit
     readonly reason: "multiple_expressions";
     readonly code: JsonRpcErrorCode.ValidationError;
     readonly thrownBy: "service";
-    readonly when: "Expression contains a separator (`;` or newline) outside matrix brackets.";
+    readonly when: "Expression holds more than one statement — a `;` or newline at the top level, outside brackets, parentheses, and string literals.";
     readonly recovery: "Send one expression per call; issue separate calls for each statement.";
 }, {
     readonly reason: "reserved_scope_key";
@@ -60,32 +60,50 @@ export declare const calculateTool: import("@cyanheads/mcp-ts-core").ToolDefinit
     readonly reason: "disallowed_result_type";
     readonly code: JsonRpcErrorCode.ValidationError;
     readonly thrownBy: "service";
-    readonly when: "Result is a function, parser, or multi-expression ResultSet, or the expression converts a function to a string (e.g. `cos.toString()`) — security guard.";
-    readonly recovery: "Rewrite the expression to produce a value (number, matrix, unit) instead of a function or its source.";
+    readonly when: "The result is a function (e.g. a bare `sin`, or `f(x) = x^2`) or a help() object, or the expression converts a function to a string (e.g. `cos.toString()`) — security guard.";
+    readonly recovery: "Rewrite the expression to produce a value (number, matrix, unit) instead of a function or its source; for function documentation, read the calculator://help resource.";
 }, {
     readonly reason: "result_too_large";
     readonly code: JsonRpcErrorCode.ValidationError;
     readonly thrownBy: "service";
-    readonly when: "Stringified result exceeds the configured max size (CALC_MAX_RESULT_LENGTH).";
+    readonly when: `The result exceeds the configured max size (CALC_MAX_RESULT_LENGTH), or the expression would build a matrix or string over the per-call limit (${string} elements or characters), or more than ${string} in total across one evaluation.`;
     readonly recovery: "Reduce precision, narrow the input range, or compute smaller subproblems separately.";
 }, {
     readonly reason: "undefined_result";
     readonly code: JsonRpcErrorCode.ValidationError;
     readonly thrownBy: "service";
-    readonly when: "Expression evaluated to Infinity, -Infinity, or NaN (e.g., division by zero).";
-    readonly recovery: "Check for division by zero, log of non-positive numbers, or other undefined operations.";
+    readonly when: "The result is Infinity, -Infinity, or NaN anywhere in it (including matrix elements, unit magnitudes, and object values): an undefined operation such as 1/0, 0/0, or log(0), or a value that overflowed its numeric range (e.g. 171! or 2^1024 under numericType \"number\").";
+    readonly recovery: "Division by zero, 0/0, and log(0) are undefined in every numericType, so fix the expression; for an overflow (large powers, factorials, exp), retry with numericType \"BigNumber\".";
 }, {
     readonly reason: "fraction_unsupported";
     readonly code: JsonRpcErrorCode.ValidationError;
     readonly thrownBy: "service";
-    readonly when: "numericType is \"Fraction\" but the expression has no exact rational value (irrational or transcendental result, e.g. sqrt, sin, log).";
-    readonly recovery: "Retry with numericType \"number\" or \"BigNumber\" — those represent irrational and transcendental results.";
+    readonly when: "numericType is \"Fraction\" and the result has no exact rational value (e.g. sqrt(2), sin(1), log(3)), the expression calls a function Fraction mode cannot compute, even for a rational result (e.g. sqrt(4), 5!, combinations(5, 2)), or it uses a value Fraction mode holds only as a rounded 64-bit float (e.g. pi, e, 2^(1/2), a complex number with a non-integer part, number(x), random()).";
+    readonly recovery: "Retry with numericType \"number\" or \"BigNumber\" — both compute these functions and values, including irrational and transcendental results.";
 }, {
     readonly reason: "parse_failed";
     readonly code: JsonRpcErrorCode.ValidationError;
     readonly thrownBy: "service";
-    readonly when: "mathjs could not parse the expression.";
-    readonly recovery: "Check syntax for balanced parentheses, valid operators, and correct function names.";
+    readonly when: "mathjs could not parse the expression, or it names an undefined symbol, function, or unit, or calls a function disabled for security.";
+    readonly recovery: "Check syntax for balanced parentheses, valid operators, and correct function and unit names; pass variable values through scope.";
+}, {
+    readonly reason: "operation_as_function";
+    readonly code: JsonRpcErrorCode.ValidationError;
+    readonly thrownBy: "service";
+    readonly when: "The expression calls `evaluate`, `simplify`, or `derivative` — those are operations, selected with the `operation` parameter.";
+    readonly recovery: "Send the inner expression as `expression` with `operation` set to that function name; for `derivative`, also pass `variable`.";
+}, {
+    readonly reason: "type_mismatch";
+    readonly code: JsonRpcErrorCode.ValidationError;
+    readonly thrownBy: "service";
+    readonly when: "An operand has the wrong type or unit for the operation — a bare number added to a unit, mismatched units, a unit in an exponent, a non-numeric string in arithmetic, or a function used as a value (`5 min`, where `min` is the minimum function; that case carries its own recovery hint).";
+    readonly recovery: "Attach the same unit to the bare operand (`5 kg + 3 kg`) or strip it (`number(5 kg, \"kg\") + 3`), keep exponents unitless, and use numbers instead of strings.";
+}, {
+    readonly reason: "evaluation_failed";
+    readonly code: JsonRpcErrorCode.ValidationError;
+    readonly thrownBy: "service";
+    readonly when: "The expression parsed but could not be computed — wrong argument count, a value outside the function domain, a singular matrix, mismatched matrix dimensions, or an index out of range — or simplify/derivative cannot process part of it (e.g. a function with no derivative rule).";
+    readonly recovery: "The syntax is valid — fix the argument the error message names (its count, value range, or matrix dimensions) and retry.";
 }, {
     readonly reason: "derivative_missing_variable";
     readonly code: JsonRpcErrorCode.ValidationError;

package/dist/mcp-server/tools/definitions/calculate.tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"calculate.tool.d.ts","sourceRoot":"","sources":["../../../../src/mcp-server/tools/definitions/calculate.tool.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAQ,CAAC,EAAE,MAAM,wBAAwB,CAAC;AACjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAGjE,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA2PxB,CAAC"}
+{"version":3,"file":"calculate.tool.d.ts","sourceRoot":"","sources":["../../../../src/mcp-server/tools/definitions/calculate.tool.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAQ,CAAC,EAAE,MAAM,wBAAwB,CAAC;AACjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAIjE,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAoRxB,CAAC"}

package/dist/mcp-server/tools/definitions/calculate.tool.js

@@ -6,6 +6,7 @@
 import { tool, z } from '@cyanheads/mcp-ts-core';
 import { JsonRpcErrorCode } from '@cyanheads/mcp-ts-core/errors';
 import { getMathService } from '../../../services/math/math-service.js';
+import { MAX_EVALUATION_ELEMENTS, MAX_MATRIX_ELEMENTS } from '../../../services/math/size-guard.js';
 export const calculateTool = tool('calculate', {
     description: 'Evaluate math expressions, simplify algebraic expressions, or compute symbolic derivatives. One expression per call. Supports arithmetic, trigonometry, statistics, matrices, complex numbers, units, and combinatorics.',
     annotations: {
@@ -17,7 +18,7 @@ export const calculateTool = tool('calculate', {
         expression: z
             .string()
             .min(1)
-            .describe(`One mathematical expression per call — neither \`;\` nor newlines separate statements. Inside matrices, \`;\` separates rows (e.g. \`[1, 2; 3, 4]\`). Supports arithmetic (+, -, *, /, ^, %), functions across arithmetic/trig (sin, cos, sqrt, log, abs, round), statistics (mean, median, std, variance), combinatorics (factorial, permutations, combinations), and matrix (det, inv, transpose), plus constants (pi, e, phi, i), units (5 kg to lbs), and variables (when scope is provided). Standard notation \`ln\` and \`arc*\` (e.g. \`arcsin\`, \`arctan\`) is accepted alongside the math.js names \`log\` and \`asin\`/\`atan\`; common synonyms such as \`stdev\`, \`permute\`, \`nCr\`, and \`length\`/\`len\` resolve to their math.js names (\`std\`, \`permutations\`, \`combinations\`, \`count\`).`),
+            .describe(`One mathematical expression per call — neither \`;\` nor newlines separate statements. Inside matrices, \`;\` separates rows (e.g. \`[1, 2; 3, 4]\`). Supports arithmetic (+, -, *, /, ^, %), functions across arithmetic/trig (sin, cos, sqrt, log, abs, round), statistics (mean, median, std, variance — std and variance return the sample (n − 1) form by default; pass "uncorrected" for the population form, e.g. \`std([2, 4, 6], "uncorrected")\`), combinatorics (factorial, permutations, combinations), and matrix (det, inv, transpose), plus constants (pi, e, phi, i), units (5 kg to lbs), and variables (when scope is provided). Standard notation \`ln\` and \`arc*\` (e.g. \`arcsin\`, \`arctan\`) is accepted alongside the math.js names \`log\` and \`asin\`/\`atan\`; common synonyms such as \`stdev\`, \`permute\`, \`nCr\`, and \`length\`/\`len\` resolve to their math.js names (\`std\`, \`permutations\`, \`combinations\`, \`count\`).`),
         operation: z
             .enum(['evaluate', 'simplify', 'derivative'])
             .default('evaluate')
@@ -36,24 +37,24 @@ export const calculateTool = tool('calculate', {
         scope: z
             .record(z.string(), z.number())
             .optional()
-            .describe('Variable assignments for the expression. Example: { "x": 5, "y": 3 } makes "x + y" evaluate to 8.'),
+            .describe('Variable assignments for evaluate; simplify and derivative ignore them. Example: { "x": 5, "y": 3 } makes "x + y" evaluate to 8.'),
         precision: z
             .union([
             z.literal('').describe('Empty string — treated as omitted.'),
             z.number().int().min(1).max(16).describe('Significant digits (integer, 1–16).'),
         ])
             .optional()
-            .describe('Significant digits (1–16) for numeric results. Omit for full precision. Empty string is treated as omitted. Ignored for symbolic operations (simplify, derivative).'),
+            .describe('Significant digits (1–16) for numeric results. Omit for full precision. Empty string is treated as omitted. Fraction results always print exactly, and symbolic operations (simplify, derivative) ignore it.'),
         numericType: z
             .enum(['number', 'BigNumber', 'Fraction'])
             .default('number')
-            .describe('Numeric type for evaluate. "number" (default): 64-bit IEEE 754 float — fastest, standard precision. "BigNumber": arbitrary-precision decimal — use when intermediate values overflow 64-bit float (e.g. large factorial ratios like 10000!/9999!); slower than "number". "Fraction": exact rational arithmetic — eliminates floating-point rounding (e.g. 0.1 + 0.2 = 0.3 exactly); limited to expressions with exactly-rational results — an irrational or transcendental result (sqrt, sin, log, …) fails with fraction_unsupported, so use "number" or "BigNumber" for those. Ignored for symbolic operations (simplify, derivative). When "number" evaluation produces a non-finite result (undefined_result error), retry with "BigNumber".'),
+            .describe('Numeric type for evaluate. "number" (default): 64-bit IEEE 754 float — fastest, about 16 significant digits; a value past about 1.8e308 (171!, 2^1024, exp(1000)) overflows and fails with undefined_result. "BigNumber": decimal with 64 significant digits and a much wider exponent range, slower than "number" — retry an overflow with it; results are 64-digit approximations (10000!/9999! returns 9999.99…96, which precision: 16 rounds to 10000). Division by zero, 0/0, and log(0) are undefined in every numeric type, so another numeric type does not fix them. "Fraction": exact rational arithmetic (0.1 + 0.2 returns 3/10); fails with fraction_unsupported when the result has no exact rational value (sqrt(2), sin(1), log(3)), the expression calls a function Fraction mode cannot compute (sqrt(4), 5!, combinations(5, 2)), or it uses a value Fraction mode holds only as a rounded float (pi, e, 2^(1/2), a complex number with a non-integer part, number(x), random()) — use "number" or "BigNumber" for those. A unit conversion with an irrational factor (30 deg to rad) returns a close rational approximation, not an exact value. Ignored for symbolic operations (simplify, derivative).'),
     }),
     output: z.object({
         result: z.string().describe('The computed result as a string.'),
         resultType: z
             .string()
-            .describe('Type of result as reported by math.js: number, BigNumber, Complex, DenseMatrix, Unit, string, boolean. Symbolic operations return "string".'),
+            .describe('Type of result as reported by math.js. Common values: number, BigNumber, Fraction, Complex, DenseMatrix, SparseMatrix, Array, Unit, string, boolean. Symbolic operations return "string".'),
         expression: z.string().describe('The original expression as received.'),
         operation: z
             .enum(['evaluate', 'simplify', 'derivative'])
@@ -61,11 +62,11 @@ export const calculateTool = tool('calculate', {
         scopeVars: z
             .array(z.string())
             .optional()
-            .describe('Keys from the scope that were active during evaluation. Omitted when no scope was provided. Values are omitted to keep output compact.'),
+            .describe('Keys from the scope that were active during evaluation. Omitted when no scope was provided and for symbolic operations, which ignore scope. Values are omitted to keep output compact.'),
         precisionUsed: z
             .number()
             .optional()
-            .describe('Significant-digit precision applied to the result. Omitted when full precision was used or the operation is symbolic.'),
+            .describe('The precision value supplied for evaluate. Fraction results print exactly regardless. Omitted when no precision was supplied or the operation is symbolic.'),
         unchanged: z
             .boolean()
             .optional()
@@ -90,7 +91,7 @@ export const calculateTool = tool('calculate', {
             reason: 'multiple_expressions',
             code: JsonRpcErrorCode.ValidationError,
             thrownBy: 'service',
-            when: 'Expression contains a separator (`;` or newline) outside matrix brackets.',
+            when: 'Expression holds more than one statement — a `;` or newline at the top level, outside brackets, parentheses, and string literals.',
             recovery: 'Send one expression per call; issue separate calls for each statement.',
         },
         {
@@ -104,36 +105,57 @@ export const calculateTool = tool('calculate', {
             reason: 'disallowed_result_type',
             code: JsonRpcErrorCode.ValidationError,
             thrownBy: 'service',
-            when: 'Result is a function, parser, or multi-expression ResultSet, or the expression converts a function to a string (e.g. `cos.toString()`) — security guard.',
-            recovery: 'Rewrite the expression to produce a value (number, matrix, unit) instead of a function or its source.',
+            when: 'The result is a function (e.g. a bare `sin`, or `f(x) = x^2`) or a help() object, or the expression converts a function to a string (e.g. `cos.toString()`) — security guard.',
+            recovery: 'Rewrite the expression to produce a value (number, matrix, unit) instead of a function or its source; for function documentation, read the calculator://help resource.',
         },
         {
             reason: 'result_too_large',
             code: JsonRpcErrorCode.ValidationError,
             thrownBy: 'service',
-            when: 'Stringified result exceeds the configured max size (CALC_MAX_RESULT_LENGTH).',
+            when: `The result exceeds the configured max size (CALC_MAX_RESULT_LENGTH), or the expression would build a matrix or string over the per-call limit (${MAX_MATRIX_ELEMENTS.toLocaleString('en-US')} elements or characters), or more than ${MAX_EVALUATION_ELEMENTS.toLocaleString('en-US')} in total across one evaluation.`,
             recovery: 'Reduce precision, narrow the input range, or compute smaller subproblems separately.',
         },
         {
             reason: 'undefined_result',
             code: JsonRpcErrorCode.ValidationError,
             thrownBy: 'service',
-            when: 'Expression evaluated to Infinity, -Infinity, or NaN (e.g., division by zero).',
-            recovery: 'Check for division by zero, log of non-positive numbers, or other undefined operations.',
+            when: 'The result is Infinity, -Infinity, or NaN anywhere in it (including matrix elements, unit magnitudes, and object values): an undefined operation such as 1/0, 0/0, or log(0), or a value that overflowed its numeric range (e.g. 171! or 2^1024 under numericType "number").',
+            recovery: 'Division by zero, 0/0, and log(0) are undefined in every numericType, so fix the expression; for an overflow (large powers, factorials, exp), retry with numericType "BigNumber".',
         },
         {
             reason: 'fraction_unsupported',
             code: JsonRpcErrorCode.ValidationError,
             thrownBy: 'service',
-            when: 'numericType is "Fraction" but the expression has no exact rational value (irrational or transcendental result, e.g. sqrt, sin, log).',
-            recovery: 'Retry with numericType "number" or "BigNumber" — those represent irrational and transcendental results.',
+            when: 'numericType is "Fraction" and the result has no exact rational value (e.g. sqrt(2), sin(1), log(3)), the expression calls a function Fraction mode cannot compute, even for a rational result (e.g. sqrt(4), 5!, combinations(5, 2)), or it uses a value Fraction mode holds only as a rounded 64-bit float (e.g. pi, e, 2^(1/2), a complex number with a non-integer part, number(x), random()).',
+            recovery: 'Retry with numericType "number" or "BigNumber" — both compute these functions and values, including irrational and transcendental results.',
         },
         {
             reason: 'parse_failed',
             code: JsonRpcErrorCode.ValidationError,
             thrownBy: 'service',
-            when: 'mathjs could not parse the expression.',
-            recovery: 'Check syntax for balanced parentheses, valid operators, and correct function names.',
+            when: 'mathjs could not parse the expression, or it names an undefined symbol, function, or unit, or calls a function disabled for security.',
+            recovery: 'Check syntax for balanced parentheses, valid operators, and correct function and unit names; pass variable values through scope.',
+        },
+        {
+            reason: 'operation_as_function',
+            code: JsonRpcErrorCode.ValidationError,
+            thrownBy: 'service',
+            when: 'The expression calls `evaluate`, `simplify`, or `derivative` — those are operations, selected with the `operation` parameter.',
+            recovery: 'Send the inner expression as `expression` with `operation` set to that function name; for `derivative`, also pass `variable`.',
+        },
+        {
+            reason: 'type_mismatch',
+            code: JsonRpcErrorCode.ValidationError,
+            thrownBy: 'service',
+            when: 'An operand has the wrong type or unit for the operation — a bare number added to a unit, mismatched units, a unit in an exponent, a non-numeric string in arithmetic, or a function used as a value (`5 min`, where `min` is the minimum function; that case carries its own recovery hint).',
+            recovery: 'Attach the same unit to the bare operand (`5 kg + 3 kg`) or strip it (`number(5 kg, "kg") + 3`), keep exponents unitless, and use numbers instead of strings.',
+        },
+        {
+            reason: 'evaluation_failed',
+            code: JsonRpcErrorCode.ValidationError,
+            thrownBy: 'service',
+            when: 'The expression parsed but could not be computed — wrong argument count, a value outside the function domain, a singular matrix, mismatched matrix dimensions, or an index out of range — or simplify/derivative cannot process part of it (e.g. a function with no derivative rule).',
+            recovery: 'The syntax is valid — fix the argument the error message names (its count, value range, or matrix dimensions) and retry.',
         },
         {
             reason: 'derivative_missing_variable',
@@ -197,12 +219,10 @@ export const calculateTool = tool('calculate', {
         }
     },
     format: (output) => {
-        const scopeVars = output.scopeVars && output.scopeVars.length > 0 ? output.scopeVars.join(', ') : 'none';
-        const precision = output.precisionUsed ?? 'full';
         const lines = [
-            `**Expression:** \`${output.expression}\``,
+            `**Expression:**${labeled(output.expression)}`,
             `**Operation:** ${output.operation}`,
-            `**Result:** ${output.result}`,
+            `**Result:**${labeled(output.result)}`,
             `**Type:** ${output.resultType}`,
         ];
         if (output.unchanged !== undefined) {
@@ -211,11 +231,49 @@ export const calculateTool = tool('calculate', {
                 ? '**Simplified:** unchanged — expression could not be reduced further'
                 : '**Simplified:** reduced (unchanged: false)');
         }
-        if (output.operation !== 'simplify') {
+        // Symbolic operations ignore scope and precision, so only evaluate reports them.
+        if (output.operation === 'evaluate') {
+            const scopeVars = output.scopeVars?.length
+                ? output.scopeVars.map(literal).join(', ')
+                : 'none';
             lines.push(`**Scope variables:** ${scopeVars}`);
-            lines.push(`**Precision:** ${precision}`);
+            lines.push(`**Precision:** ${output.precisionUsed ?? 'full'}`);
         }
         return [{ type: 'text', text: lines.join('\n') }];
     },
 });
+/** Length of the longest run of consecutive backticks in `value` (0 when it has none). */
+function longestBacktickRun(value) {
+    return Math.max(0, ...(value.match(/`+/g) ?? []).map((run) => run.length));
+}
+/**
+ * Render caller-influenced text so a CommonMark reader sees it byte-for-byte:
+ * a code span whose fence is one backtick longer than the value's longest
+ * backtick run, space-padded when the value starts or ends with a backtick or
+ * space (CommonMark strips one padding space from each side). A value made only
+ * of spaces is never stripped, so it goes unpadded; an empty value cannot be a
+ * code span and renders as a plain marker. A value with a line break goes in a
+ * fenced block on its own lines, sized the same way. No backslash escaping:
+ * `*`, `_`, `^`, and `[` are math syntax and must survive a copy. CommonMark
+ * normalizes a carriage return to a line feed, so a value holding one (only an
+ * expression or scope key can — math.js escapes it in results) reads back with
+ * `\n` in its place; `structuredContent` keeps the exact bytes.
+ */
+function literal(value) {
+    if (value === '')
+        return '(empty)';
+    const run = longestBacktickRun(value);
+    if (/[\r\n]/.test(value)) {
+        const fence = '`'.repeat(Math.max(3, run + 1));
+        return `\n${fence}\n${value}\n${fence}\n`;
+    }
+    const fence = '`'.repeat(run + 1);
+    const pad = /^[` ]|[` ]$/.test(value) && !/^ +$/.test(value) ? ' ' : '';
+    return `${fence}${pad}${value}${pad}${fence}`;
+}
+/** A labeled value: a code span after the label, or a fenced block below it. */
+function labeled(value) {
+    const rendered = literal(value);
+    return rendered.startsWith('\n') ? rendered.slice(0, -1) : ` ${rendered}`;
+}
 //# sourceMappingURL=calculate.tool.js.map

package/dist/mcp-server/tools/definitions/calculate.tool.js.map

@@ -1 +1 @@
-{"version":3,"file":"calculate.tool.js","sourceRoot":"","sources":["../../../../src/mcp-server/tools/definitions/calculate.tool.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"calculate.tool.js","sourceRoot":"","sources":["../../../../src/mcp-server/tools/definitions/calculate.tool.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,IAAI,EAAE,CAAC,EAAE,MAAM,wBAAwB,CAAC;AACjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AACjE,OAAO,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,EAAE,uBAAuB,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AAE7F,MAAM,CAAC,MAAM,aAAa,GAAG,IAAI,CAAC,WAAW,EAAE;IAC7C,WAAW,EACT,0NAA0N;IAC5N,WAAW,EAAE;QACX,YAAY,EAAE,IAAI;QAClB,cAAc,EAAE,IAAI;QACpB,aAAa,EAAE,KAAK;KACrB;IACD,KAAK,EAAE,CAAC,CAAC,MAAM,CAAC;QACd,UAAU,EAAE,CAAC;aACV,MAAM,EAAE;aACR,GAAG,CAAC,CAAC,CAAC;aACN,QAAQ,CACP,w6BAAw6B,CACz6B;QACH,SAAS,EAAE,CAAC;aACT,IAAI,CAAC,CAAC,UAAU,EAAE,UAAU,EAAE,YAAY,CAAC,CAAC;aAC5C,OAAO,CAAC,UAAU,CAAC;aACnB,QAAQ,CACP,+dAA+d,CAChe;QACH,QAAQ,EAAE,CAAC;aACR,KAAK,CAAC;YACL,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,oCAAoC,CAAC;YAC5D,CAAC;iBACE,MAAM,EAAE;iBACR,GAAG,CAAC,EAAE,CAAC;iBACP,KAAK,CACJ,0BAA0B,EAC1B,wDAAwD,CACzD;iBACA,QAAQ,CAAC,mEAAmE,CAAC;SACjF,CAAC;aACD,QAAQ,EAAE;aACV,QAAQ,CACP,uIAAuI,CACxI;QACH,KAAK,EAAE,CAAC;aACL,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC;aAC9B,QAAQ,EAAE;aACV,QAAQ,CACP,kIAAkI,CACnI;QACH,SAAS,EAAE,CAAC;aACT,KAAK,CAAC;YACL,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,oCAAoC,CAAC;YAC5D,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,qCAAqC,CAAC;SAChF,CAAC;aACD,QAAQ,EAAE;aACV,QAAQ,CACP,8MAA8M,CAC/M;QACH,WAAW,EAAE,CAAC;aACX,IAAI,CAAC,CAAC,QAAQ,EAAE,WAAW,EAAE,UAAU,CAAC,CAAC;aACzC,OAAO,CAAC,QAAQ,CAAC;aACjB,QAAQ,CACP,8pCAA8pC,CAC/pC;KACJ,CAAC;IACF,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC;QACf,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,kCAAkC,CAAC;QAC/D,UAAU,EAAE,CAAC;aACV,MAAM,EAAE;aACR,QAAQ,CACP,2LAA2L,CAC5L;QACH,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,sCAAsC,CAAC;QACvE,SAAS,EAAE,CAAC;aACT,IAAI,CAAC,CAAC,UAAU,EAAE,UAAU,EAAE,YAAY,CAAC,CAAC;aAC5C,QAAQ,CAAC,iCAAiC,CAAC;QAC9C,SAAS,EAAE,CAAC;aACT,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;aACjB,QAAQ,EAAE;aACV,QAAQ,CACP,wLAAwL,CACzL;QACH,aAAa,EAAE,CAAC;aACb,MAAM,EAAE;aACR,QAAQ,EAAE;aACV,QAAQ,CACP,4JAA4J,CAC7J;QACH,SAAS,EAAE,CAAC;aACT,OAAO,EAAE;aACT,QAAQ,EAAE;aACV,QAAQ,CACP,wTAAwT,CACzT;KACJ,CAAC;IACF,MAAM,EAAE;QACN;YACE,MAAM,EAAE,kBAAkB;YAC1B,IAAI,EAAE,gBAAgB,CAAC,eAAe;YACtC,QAAQ,EAAE,SAAS;YACnB,IAAI,EAAE,yCAAyC;YAC/C,QAAQ,EAAE,kEAAkE;SAC7E;QACD;YACE,MAAM,EAAE,qBAAqB;YAC7B,IAAI,EAAE,gBAAgB,CAAC,eAAe;YACtC,QAAQ,EAAE,SAAS;YACnB,IAAI,EAAE,4EAA4E;YAClF,QAAQ,EAAE,kEAAkE;SAC7E;QACD;YACE,MAAM,EAAE,sBAAsB;YAC9B,IAAI,EAAE,gBAAgB,CAAC,eAAe;YACtC,QAAQ,EAAE,SAAS;YACnB,IAAI,EAAE,mIAAmI;YACzI,QAAQ,EAAE,wEAAwE;SACnF;QACD;YACE,MAAM,EAAE,oBAAoB;YAC5B,IAAI,EAAE,gBAAgB,CAAC,eAAe;YACtC,QAAQ,EAAE,SAAS;YACnB,IAAI,EAAE,gFAAgF;YACtF,QAAQ,EAAE,kEAAkE;SAC7E;QACD;YACE,MAAM,EAAE,wBAAwB;YAChC,IAAI,EAAE,gBAAgB,CAAC,eAAe;YACtC,QAAQ,EAAE,SAAS;YACnB,IAAI,EAAE,+KAA+K;YACrL,QAAQ,EACN,wKAAwK;SAC3K;QACD;YACE,MAAM,EAAE,kBAAkB;YAC1B,IAAI,EAAE,gBAAgB,CAAC,eAAe;YACtC,QAAQ,EAAE,SAAS;YACnB,IAAI,EAAE,kJAAkJ,mBAAmB,CAAC,cAAc,CAAC,OAAO,CAAC,0CAA0C,uBAAuB,CAAC,cAAc,CAAC,OAAO,CAAC,kCAAkC;YAC9T,QAAQ,EACN,sFAAsF;SACzF;QACD;YACE,MAAM,EAAE,kBAAkB;YAC1B,IAAI,EAAE,gBAAgB,CAAC,eAAe;YACtC,QAAQ,EAAE,SAAS;YACnB,IAAI,EAAE,8QAA8Q;YACpR,QAAQ,EACN,mLAAmL;SACtL;QACD;YACE,MAAM,EAAE,sBAAsB;YAC9B,IAAI,EAAE,gBAAgB,CAAC,eAAe;YACtC,QAAQ,EAAE,SAAS;YACnB,IAAI,EAAE,mYAAmY;YACzY,QAAQ,EACN,4IAA4I;SAC/I;QACD;YACE,MAAM,EAAE,cAAc;YACtB,IAAI,EAAE,gBAAgB,CAAC,eAAe;YACtC,QAAQ,EAAE,SAAS;YACnB,IAAI,EAAE,uIAAuI;YAC7I,QAAQ,EACN,kIAAkI;SACrI;QACD;YACE,MAAM,EAAE,uBAAuB;YAC/B,IAAI,EAAE,gBAAgB,CAAC,eAAe;YACtC,QAAQ,EAAE,SAAS;YACnB,IAAI,EAAE,+HAA+H;YACrI,QAAQ,EACN,+HAA+H;SAClI;QACD;YACE,MAAM,EAAE,eAAe;YACvB,IAAI,EAAE,gBAAgB,CAAC,eAAe;YACtC,QAAQ,EAAE,SAAS;YACnB,IAAI,EAAE,8RAA8R;YACpS,QAAQ,EACN,+JAA+J;SAClK;QACD;YACE,MAAM,EAAE,mBAAmB;YAC3B,IAAI,EAAE,gBAAgB,CAAC,eAAe;YACtC,QAAQ,EAAE,SAAS;YACnB,IAAI,EAAE,sRAAsR;YAC5R,QAAQ,EACN,0HAA0H;SAC7H;QACD;YACE,MAAM,EAAE,6BAA6B;YACrC,IAAI,EAAE,gBAAgB,CAAC,eAAe;YACtC,IAAI,EAAE,8DAA8D;YACpE,QAAQ,EAAE,yEAAyE;SACpF;QACD;YACE,MAAM,EAAE,oBAAoB;YAC5B,IAAI,EAAE,gBAAgB,CAAC,OAAO;YAC9B,QAAQ,EAAE,SAAS;YACnB,IAAI,EAAE,qFAAqF;YAC3F,SAAS,EAAE,KAAK;YAChB,QAAQ,EACN,uFAAuF;SAC1F;KACF;IAED,OAAO,CAAC,KAAK,EAAE,GAAG;QAChB,MAAM,IAAI,GAAG,cAAc,EAAE,CAAC;QAC9B,MAAM,EAAE,UAAU,EAAE,SAAS,EAAE,KAAK,EAAE,GAAG,KAAK,CAAC;QAC/C,MAAM,QAAQ,GAAG,KAAK,CAAC,QAAQ,IAAI,SAAS,CAAC;QAC7C,MAAM,SAAS,GAAG,OAAO,KAAK,CAAC,SAAS,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC;QACpF,MAAM,WAAW,GAAG,KAAK,CAAC,WAAW,CAAC;QAEtC,QAAQ,SAAS,EAAE,CAAC;YAClB,KAAK,UAAU;gBACb,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,sBAAsB,EAAE,EAAE,UAAU,EAAE,WAAW,EAAE,CAAC,CAAC;gBAClE,OAAO;oBACL,GAAG,IAAI,CAAC,kBAAkB,CAAC,UAAU,EAAE,GAAG,EAAE,KAAK,EAAE,SAAS,EAAE,WAAW,CAAC;oBAC1E,UAAU;oBACV,SAAS;oBACT,wEAAwE;oBACxE,uEAAuE;oBACvE,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;oBACnD,GAAG,CAAC,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,aAAa,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;iBACjE,CAAC;YACJ,KAAK,UAAU,EAAE,CAAC;gBAChB,MAAM,cAAc,GAAG,IAAI,CAAC,kBAAkB,CAAC,UAAU,EAAE,GAAG,CAAC,CAAC;gBAChE,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,uBAAuB,EAAE,EAAE,UAAU,EAAE,SAAS,EAAE,cAAc,CAAC,SAAS,EAAE,CAAC,CAAC;gBAC3F,uEAAuE;gBACvE,6EAA6E;gBAC7E,OAAO;oBACL,MAAM,EAAE,cAAc,CAAC,MAAM;oBAC7B,UAAU,EAAE,cAAc,CAAC,UAAU;oBACrC,UAAU;oBACV,SAAS;oBACT,SAAS,EAAE,cAAc,CAAC,SAAS;iBACpC,CAAC;YACJ,CAAC;YACD,KAAK,YAAY;gBACf,IAAI,CAAC,QAAQ,EAAE,CAAC;oBACd,MAAM,GAAG,CAAC,IAAI,CACZ,6BAA6B,EAC7B,sEAAsE,EACtE,EAAE,GAAG,GAAG,CAAC,WAAW,CAAC,6BAA6B,CAAC,EAAE,CACtD,CAAC;gBACJ,CAAC;gBACD,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,2BAA2B,EAAE,EAAE,UAAU,EAAE,QAAQ,EAAE,CAAC,CAAC;gBACpE,uEAAuE;gBACvE,OAAO;oBACL,GAAG,IAAI,CAAC,uBAAuB,CAAC,UAAU,EAAE,QAAQ,EAAE,GAAG,CAAC;oBAC1D,UAAU;oBACV,SAAS;iBACV,CAAC;YACJ;gBACE,MAAM,IAAI,KAAK,CAAC,wBAAwB,SAAmB,EAAE,CAAC,CAAC;QACnE,CAAC;IACH,CAAC;IAED,MAAM,EAAE,CAAC,MAAM,EAAE,EAAE;QACjB,MAAM,KAAK,GAAG;YACZ,kBAAkB,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC,EAAE;YAC9C,kBAAkB,MAAM,CAAC,SAAS,EAAE;YACpC,cAAc,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE;YACtC,aAAa,MAAM,CAAC,UAAU,EAAE;SACjC,CAAC;QACF,IAAI,MAAM,CAAC,SAAS,KAAK,SAAS,EAAE,CAAC;YACnC,qFAAqF;YACrF,KAAK,CAAC,IAAI,CACR,MAAM,CAAC,SAAS;gBACd,CAAC,CAAC,qEAAqE;gBACvE,CAAC,CAAC,4CAA4C,CACjD,CAAC;QACJ,CAAC;QACD,iFAAiF;QACjF,IAAI,MAAM,CAAC,SAAS,KAAK,UAAU,EAAE,CAAC;YACpC,MAAM,SAAS,GAAG,MAAM,CAAC,SAAS,EAAE,MAAM;gBACxC,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;gBAC1C,CAAC,CAAC,MAAM,CAAC;YACX,KAAK,CAAC,IAAI,CAAC,wBAAwB,SAAS,EAAE,CAAC,CAAC;YAChD,KAAK,CAAC,IAAI,CAAC,kBAAkB,MAAM,CAAC,aAAa,IAAI,MAAM,EAAE,CAAC,CAAC;QACjE,CAAC;QACD,OAAO,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACpD,CAAC;CACF,CAAC,CAAC;AAEH,0FAA0F;AAC1F,SAAS,kBAAkB,CAAC,KAAa;IACvC,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;AAC7E,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,SAAS,OAAO,CAAC,KAAa;IAC5B,IAAI,KAAK,KAAK,EAAE;QAAE,OAAO,SAAS,CAAC;IACnC,MAAM,GAAG,GAAG,kBAAkB,CAAC,KAAK,CAAC,CAAC;IACtC,IAAI,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;QACzB,MAAM,KAAK,GAAG,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;QAC/C,OAAO,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,IAAI,CAAC;IAC5C,CAAC;IACD,MAAM,KAAK,GAAG,GAAG,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC;IAClC,MAAM,GAAG,GAAG,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;IACxE,OAAO,GAAG,KAAK,GAAG,GAAG,GAAG,KAAK,GAAG,GAAG,GAAG,KAAK,EAAE,CAAC;AAChD,CAAC;AAED,gFAAgF;AAChF,SAAS,OAAO,CAAC,KAAa;IAC5B,MAAM,QAAQ,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;IAChC,OAAO,QAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,QAAQ,EAAE,CAAC;AAC5E,CAAC"}