calculator-mcp-server

Previous value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"

Added value: +false

Previous value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"

Added value: +[
+  {
+    "not": {
+      "required": [
+        "error"
+      ]
+    },
+    "required": [
+      "result",
+      "resultType",
+      "expression",
+      "operation"
+    ]
+  },
+  {
+    "required": [
+      "error"
+    ]
+  }
+]

Added value: +{
+  "additionalProperties": {},
+  "description": "Present when the call failed. Absent on success.",
+  "properties": {
+    "code": {
+      "description": "JSON-RPC error code for this failure.",
+      "maximum": 9007199254740991,
+      "minimum": -9007199254740991,
+      "type": "integer"
+    },
+    "data": {
+      "additionalProperties": {},
+      "properties": {
+        "reason": {
+          "description": "Machine-readable failure mode. Declared by this tool: `empty_expression`: Expression is empty or whitespace-only. `expression_too_long`: Expression exceeds the configured max length (CALC_MAX_EXPRESSION_LENGTH). `multiple_expressions`: Expression contains a separator (`;` or newline) outside matrix brackets. `reserved_scope_key`: Scope contains a reserved JS property name (`__proto__`, `constructor`, etc.). `disallowed_result_type`: Result is a function, parser, or multi-expression ResultSet, or the expression converts a function to a string (e.g. `cos.toString()`) — security guard. `result_too_large`: Stringified result exceeds the configured max size (CALC_MAX_RESULT_LENGTH). `undefined_result`: Expression evaluated to Infinity, -Infinity, or NaN (e.g., division by zero). `fraction_unsupported`: numericType is \"Fraction\" but the expression has no exact rational value (irrational or transcendental result, e.g. sqrt, sin, log). `parse_failed`: mathjs could not parse the expression. `derivative_missing_variable`: `operation` is `derivative` but `variable` was not provided. `evaluation_timeout`: Expression evaluation exceeded the configured timeout (CALC_EVALUATION_TIMEOUT_MS). Other values are possible when a failure originates below the handler.",
+          "examples": [
+            "empty_expression",
+            "expression_too_long",
+            "multiple_expressions",
+            "reserved_scope_key",
+            "disallowed_result_type",
+            "result_too_large",
+            "undefined_result",
+            "fraction_unsupported",
+            "parse_failed",
+            "derivative_missing_variable",
+            "evaluation_timeout"
+          ],
+          "type": "string"
+        },
+        "recovery": {
+          "additionalProperties": {},
+          "description": "Actionable next step for the caller.",
+          "properties": {
+            "hint": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "hint"
+          ],
+          "type": "object"
+        },
+        "retryable": {
+          "description": "Whether retrying may succeed.",
+          "type": "boolean"
+        }
+      },
+      "type": "object"
+    },
+    "message": {
+      "description": "Human-readable description of what went wrong.",
+      "type": "string"
+    }
+  },
+  "required": [
+    "code",
+    "message"
+  ],
+  "type": "object"
+}

Removed value: -[
-  "result",
-  "resultType",
-  "expression",
-  "operation"
-]

Previous value: -"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`, and `nCr` resolve to their math.js names (`std`, `permutations`, `combinations`)."New value: +"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`)."

Previous value: -"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 without transcendental functions. Ignored for symbolic operations (simplify, derivative). When \"number\" evaluation produces a non-finite result (undefined_result error), retry with \"BigNumber\"."New value: +"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\"."

Previous value: -"One mathematical expression per call — neither `;` nor newlines separate statements. Inside matrices, `;` separates rows (e.g. `[1, 2; 3, 4]`). Supports arithmetic (+, -, *, /, ^, %), functions (sin, cos, sqrt, log, abs, round, etc.), constants (pi, e, phi, i), matrices, 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`."New value: +"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`, and `nCr` resolve to their math.js names (`std`, `permutations`, `combinations`)."

Added value: +{
+  "default": "number",
+  "description": "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 without transcendental functions. Ignored for symbolic operations (simplify, derivative). When \"number\" evaluation produces a non-finite result (undefined_result error), retry with \"BigNumber\".",
+  "enum": [
+    "number",
+    "BigNumber",
+    "Fraction"
+  ],
+  "type": "string"
+}

Previous value: -"Operation to perform. \"evaluate\" computes a numeric result (default). \"simplify\" reduces an algebraic expression symbolically (e.g., \"2x + 3x\" -> \"5 * x\"). Supports algebraic and trigonometric identities. \"derivative\" computes the symbolic derivative (requires the variable parameter)."New value: +"Operation to perform. \"evaluate\" computes a numeric result (default). \"simplify\" reduces an algebraic expression symbolically (e.g., \"2x + 3x\" -> \"5 * x\"). Supports algebraic and trigonometric identities. When the simplifier cannot reduce the expression further (e.g. rational expressions requiring polynomial factoring), the result is returned unchanged and unchanged: true is set in the output. \"derivative\" computes the symbolic derivative (requires the variable parameter)."

Added value: +{
+  "description": "Present only for simplify operations. true means the simplifier returned the expression unchanged — it could not reduce it further (e.g. rational expressions requiring polynomial factoring are beyond math.js's built-in simplifier). false means simplification made progress. Omitted for evaluate and derivative.",
+  "type": "boolean"
+}

Removed value: -[
-  {
-    "type": "number"
-  },
-  {
-    "type": "null"
-  }
-]

Previous value: -"Significant-digit precision that was applied, or null when full precision was used or the operation is symbolic."New value: +"Significant-digit precision applied to the result. Omitted when full precision was used or the operation is symbolic."

Added value: +"number"

Removed value: -[
-  {
-    "items": {
-      "type": "string"
-    },
-    "type": "array"
-  },
-  {
-    "type": "null"
-  }
-]

Previous value: -"Keys from the scope that were active during evaluation, or null when no scope was provided. Values are omitted to keep output compact."New value: +"Keys from the scope that were active during evaluation. Omitted when no scope was provided. Values are omitted to keep output compact."

Added value: +{
+  "type": "string"
+}

Added value: +"array"

Previous value: -[
-  "result",
-  "resultType",
-  "expression",
-  "operation",
-  "scopeVars",
-  "precisionUsed"
-]New value: +[
+  "result",
+  "resultType",
+  "expression",
+  "operation"
+]

Previous value: -"One mathematical expression per call — neither `;` nor newlines separate statements. Inside matrices, `;` separates rows (e.g. `[1, 2; 3, 4]`). Supports arithmetic (+, -, *, /, ^, %), functions (sin, cos, sqrt, log, abs, round, etc.), constants (pi, e, phi, i), matrices, units (5 kg to lbs), and variables (when scope is provided)."New value: +"One mathematical expression per call — neither `;` nor newlines separate statements. Inside matrices, `;` separates rows (e.g. `[1, 2; 3, 4]`). Supports arithmetic (+, -, *, /, ^, %), functions (sin, cos, sqrt, log, abs, round, etc.), constants (pi, e, phi, i), matrices, 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`."

Added value: +{
+  "description": "The operation that was applied.",
+  "enum": [
+    "evaluate",
+    "simplify",
+    "derivative"
+  ],
+  "type": "string"
+}

Added value: +{
+  "anyOf": [
+    {
+      "type": "number"
+    },
+    {
+      "type": "null"
+    }
+  ],
+  "description": "Significant-digit precision that was applied, or null when full precision was used or the operation is symbolic."
+}

Added value: +{
+  "anyOf": [
+    {
+      "items": {
+        "type": "string"
+      },
+      "type": "array"
+    },
+    {
+      "type": "null"
+    }
+  ],
+  "description": "Keys from the scope that were active during evaluation, or null when no scope was provided. Values are omitted to keep output compact."
+}

Previous value: -[
-  "result",
-  "resultType",
-  "expression"
-]New value: +[
+  "result",
+  "resultType",
+  "expression",
+  "operation",
+  "scopeVars",
+  "precisionUsed"
+]

Previous value: -"Mathematical expression to evaluate. Supports standard notation: arithmetic (+, -, *, /, ^, %), functions (sin, cos, sqrt, log, abs, round, etc.), constants (pi, e, phi, i), matrices ([1, 2; 3, 4]), units (5 kg to lbs), and variables (when scope is provided)."New value: +"One mathematical expression per call — neither `;` nor newlines separate statements. Inside matrices, `;` separates rows (e.g. `[1, 2; 3, 4]`). Supports arithmetic (+, -, *, /, ^, %), functions (sin, cos, sqrt, log, abs, round, etc.), constants (pi, e, phi, i), matrices, units (5 kg to lbs), and variables (when scope is provided)."

Previous value: -[
-  {
-    "const": "",
-    "description": "Empty string — treated as omitted (for form-based clients).",
-    "type": "string"
-  },
-  {
-    "description": "Significant digits (integer, 1–16).",
-    "maximum": 16,
-    "minimum": 1,
-    "type": "integer"
-  }
-]New value: +[
+  {
+    "const": "",
+    "description": "Empty string — treated as omitted.",
+    "type": "string"
+  },
+  {
+    "description": "Significant digits (integer, 1–16).",
+    "maximum": 16,
+    "minimum": 1,
+    "type": "integer"
+  }
+]

Previous value: -"Significant digits (1–16) for numeric results. Omit for full precision. Blank values from form-based clients are treated as omitted. Ignored for symbolic operations (simplify, derivative)."New value: +"Significant digits (1–16) for numeric results. Omit for full precision. Empty string is treated as omitted. Ignored for symbolic operations (simplify, derivative)."

Previous value: -[
-  {
-    "const": "",
-    "description": "Empty string — treated as omitted (for form-based clients).",
-    "type": "string"
-  },
-  {
-    "description": "Variable identifier (alphanumeric and underscores, max 50 chars).",
-    "maxLength": 50,
-    "pattern": "^[a-zA-Z_][a-zA-Z0-9_]*$",
-    "type": "string"
-  }
-]New value: +[
+  {
+    "const": "",
+    "description": "Empty string — treated as omitted.",
+    "type": "string"
+  },
+  {
+    "description": "Variable identifier (alphanumeric and underscores, max 50 chars).",
+    "maxLength": 50,
+    "pattern": "^[a-zA-Z_][a-zA-Z0-9_]*$",
+    "type": "string"
+  }
+]

Previous value: -"Variable to differentiate with respect to. Required when operation is \"derivative\". Blank values from form-based clients are treated as omitted. Example: \"x\"."New value: +"Variable to differentiate with respect to. Required when operation is \"derivative\". Empty string is treated as omitted. Example: \"x\"."