benjivers/jev-mcp Public Public: anyone can read this; nobody can change it.

// Unit tests for the pure helpers. No network, no child process.

import assert from "node:assert/strict";

import test from "node:test";

import { APIError } from "@typesafe-ai/sdk";

import {

  assertStateWithinLimit,

  assertUniqueIds,

  buildChoiceCriteria,

  describeError,

  gateConfidence,

  gateProbability,

  MalformedResponseError,

  MAX_CHOICE_OPTIONS,

  readPositiveInt,

  resolveNoneKey,

  stateSize,

  validateChoiceAnswer,

  validateNoulAnswer,

  validateScoreAnswer,

} from "../dist/lib.js";

test("readPositiveInt falls back loudly instead of yielding NaN", () => {

  assert.deepEqual(readPositiveInt(undefined, 15000, "T"), { value: 15000 });

  assert.deepEqual(readPositiveInt("  ", 15000, "T"), { value: 15000 });

  assert.equal(readPositiveInt("500", 15000, "T").value, 500);

  assert.equal(readPositiveInt("12.7", 15000, "T").value, 12);

  for (const bad of ["abc", "0", "-5", "NaN"]) {

    const parsed = readPositiveInt(bad, 15000, "T");

    assert.equal(parsed.value, 15000, `${bad} should fall back`);

    assert.ok(parsed.warning, `${bad} should warn`);

  }

});

test("resolveNoneKey steps aside when the caller already uses the name", () => {

  assert.equal(resolveNoneKey([]), "none");

  assert.equal(resolveNoneKey(["a", "b"]), "none");

  assert.equal(resolveNoneKey(["none"]), "none_of_these");

  assert.equal(resolveNoneKey(["none", "none_of_these"]), "none_of_these_2");

});

test("buildChoiceCriteria never overwrites a caller's own option", () => {

  const callerMeaning = "The request was already handled; no action needed.";

  const { criteria, noneKey } = buildChoiceCriteria({ none: callerMeaning, escalate: "Send to a human" }, true);

  assert.equal(criteria.none, callerMeaning, "the caller's option must survive verbatim");

  assert.equal(noneKey, "none_of_these");

  assert.equal(criteria.none_of_these, "None of the other options fits.");

});

test("buildChoiceCriteria reports the no-match key it used", () => {

  const { criteria, noneKey } = buildChoiceCriteria({ a: "d", b: "d" }, true);

  assert.equal(noneKey, "none");

  assert.deepEqual(Object.keys(criteria).sort(), ["a", "b", "none"]);

  const off = buildChoiceCriteria({ a: "d", b: "d" }, false);

  assert.equal(off.noneKey, null);

  assert.deepEqual(Object.keys(off.criteria).sort(), ["a", "b"]);

});

test("buildChoiceCriteria rejects empty, single-outcome, and oversized option sets", () => {

  assert.throws(() => buildChoiceCriteria({}, true), /at least one option/);

  assert.throws(() => buildChoiceCriteria({ only: "d" }, false), /at least two outcomes/);

  const tooMany = Object.fromEntries(Array.from({ length: MAX_CHOICE_OPTIONS + 1 }, (_, i) => [`o${i}`, null]));

  assert.throws(() => buildChoiceCriteria(tooMany, false), /at most 255 options/);

  const exactlyAtLimit = Object.fromEntries(Array.from({ length: MAX_CHOICE_OPTIONS }, (_, i) => [`o${i}`, null]));

  assert.doesNotThrow(() => buildChoiceCriteria(exactlyAtLimit, false));

});

test("assertUniqueIds names the duplicates rather than dropping questions", () => {

  assert.doesNotThrow(() => assertUniqueIds(["a", "b", "c"]));

  assert.throws(() => assertUniqueIds(["a", "b", "a"]), /Duplicate question ids: "a"/);

});

test("state size is measured, and oversized state is rejected not truncated", () => {

  assert.equal(stateSize("abcde"), 5);

  assert.equal(stateSize({ a: 1 }), JSON.stringify({ a: 1 }).length);

  assert.doesNotThrow(() => assertStateWithinLimit("abc", 10));

  assert.throws(() => assertStateWithinLimit("a".repeat(20), 10), /above the 10 limit/);

});

test("gateConfidence maps confidence onto an action", () => {

  assert.equal(gateConfidence(0.95, 0.8, 0.5), "act");

  assert.equal(gateConfidence(0.8, 0.8, 0.5), "act");

  assert.equal(gateConfidence(0.6, 0.8, 0.5), "review");

  assert.equal(gateConfidence(0.2, 0.8, 0.5), "abstain");

  assert.equal(gateConfidence(null, 0.8, 0.5), "abstain");

  assert.equal(gateConfidence(undefined, 0.8, 0.5), "abstain");

});

test("gateProbability keeps the middle band uncertain instead of rounding", () => {

  assert.equal(gateProbability(0.9, 0.7, 0.3), "yes");

  assert.equal(gateProbability(0.7, 0.7, 0.3), "yes");

  assert.equal(gateProbability(0.51, 0.7, 0.3), "uncertain", "0.51 is a coin flip, not a yes");

  assert.equal(gateProbability(0.3, 0.7, 0.3), "no");

  assert.equal(gateProbability(0.05, 0.7, 0.3), "no");

});

test("describeError separates failures a caller should treat differently", () => {

  const missing = describeError(new Error("No API key. Set TYPESAFE_API_KEY in the environment."));

  assert.equal(missing.kind, "no_api_key");

  assert.equal(missing.retryable, false);

  const headers = new Headers({ "x-typesafe-request-id": "req_abc" });

  const rateLimited = describeError(APIError.fromResponse(429, {}, headers));

  assert.equal(rateLimited.kind, "rate_limit");

  assert.equal(rateLimited.retryable, true);

  assert.equal(rateLimited.status, 429);

  assert.equal(rateLimited.requestId, "req_abc");

  const unauthorized = describeError(APIError.fromResponse(401, {}, new Headers()));

  assert.equal(unauthorized.kind, "authentication");

  assert.equal(unauthorized.retryable, false, "a bad key never succeeds on retry");

  const malformed = describeError(APIError.fromResponse(422, {}, new Headers()));

  assert.equal(malformed.kind, "invalid_request");

  assert.equal(malformed.retryable, false);

  const overloaded = describeError(APIError.fromResponse(529, {}, new Headers()));

  assert.equal(overloaded.kind, "server_error");

  assert.equal(overloaded.retryable, true);

});

// ── Answer validation ───────────────────────────────────────────────────────

const KEYS = ["a", "b", "none"];

const goodChoice = { type: "choice", choice: "a", confidence: 0.8, probabilities: { a: 0.8, b: 0.15, none: 0.05 } };

test("validateChoiceAnswer accepts a well-formed answer", () => {

  assert.doesNotThrow(() => validateChoiceAnswer(goodChoice, KEYS, "q"));

});

test("validateChoiceAnswer rejects a choice that was never offered", () => {

  const answer = { ...goodChoice, choice: "c", probabilities: { a: 0.8, b: 0.15, none: 0.05 } };

  assert.throws(() => validateChoiceAnswer(answer, KEYS, "q"), MalformedResponseError);

});

test("validateChoiceAnswer rejects a distribution over the wrong options", () => {

  const missing = { ...goodChoice, probabilities: { a: 0.9, b: 0.1 } };

  assert.throws(() => validateChoiceAnswer(missing, KEYS, "q"), /offered/);

  const extra = { ...goodChoice, probabilities: { a: 0.8, b: 0.1, none: 0.05, c: 0.05 } };

  assert.throws(() => validateChoiceAnswer(extra, KEYS, "q"), /offered/);

});

test("validateChoiceAnswer rejects probabilities that do not sum to one", () => {

  const answer = { ...goodChoice, probabilities: { a: 0.9, b: 0.9, none: 0.1 } };

  assert.throws(() => validateChoiceAnswer(answer, KEYS, "q"), /summing/);

});

test("validateChoiceAnswer rejects a choice that is not the most probable option", () => {

  const answer = { ...goodChoice, choice: "b" };

  assert.throws(() => validateChoiceAnswer(answer, KEYS, "q"), /highest probability/);

});

test("validateChoiceAnswer rejects NaN, out-of-range, and missing values", () => {

  assert.throws(() => validateChoiceAnswer({ ...goodChoice, confidence: NaN }, KEYS, "q"), MalformedResponseError);

  assert.throws(() => validateChoiceAnswer({ ...goodChoice, probabilities: { a: 1.5, b: -0.4, none: -0.1 } }, KEYS, "q"), MalformedResponseError);

  assert.throws(() => validateChoiceAnswer(undefined, KEYS, "q"), /No answer/);

  assert.throws(() => validateChoiceAnswer("a", KEYS, "q"), /No answer/);

});

test("validateScoreAnswer checks the legend and distribution against the levels sent", () => {

  const good = { type: "score", score: 1.2, confidence: 0.7, legend: { 0: "low", 1: "mid", 2: "high" }, probabilities: { 0: 0.1, 1: 0.6, 2: 0.3 } };

  assert.doesNotThrow(() => validateScoreAnswer(good, 3, "r"));

  assert.throws(() => validateScoreAnswer(good, 4, "r"), /legend of 3 levels/);

  assert.throws(() => validateScoreAnswer({ ...good, score: Infinity }, 3, "r"), /finite score/);

  assert.throws(() => validateScoreAnswer({ ...good, probabilities: { 0: 0.5, 1: 0.5 } }, 3, "r"), /offered/);

});

test("validateNoulAnswer requires one probability in [0, 1]", () => {

  assert.doesNotThrow(() => validateNoulAnswer({ type: "noul", noul: 0.42 }, "c"));

  for (const bad of [{ noul: 1.2 }, { noul: NaN }, { noul: "0.4" }, {}, undefined]) {

    assert.throws(() => validateNoulAnswer(bad, "c"), MalformedResponseError);

  }

});

test("describeError classifies a malformed response as retryable and never actionable", () => {

  const described = describeError(new MalformedResponseError("bad"));

  assert.equal(described.kind, "malformed_response");

  assert.equal(described.retryable, true);

  assert.match(described.hint, /should be acted on/i);

});