@openephemeris/mcp-server 4.11.1 → 4.11.2

package/CHANGELOG.md

@@ -7,6 +7,32 @@ Version numbering follows [Semantic Versioning](https://semver.org/).
 
 ---
 
+## [4.11.2] — 2026-08-13
+
+### Fixed
+- **Location resolver rejected `"City, Country"` as ambiguous.** The
+  ambiguity qualifier matched a region name, a US state abbreviation, or a
+  two-letter ISO country *code* — but never a country *name*. So
+  `location: "Paris, France"` lost the qualification check against its US
+  namesakes and threw, while the far rarer `"Paris, fr"` resolved fine.
+  Live, `"Paris, France"` matches 8 same-named places and `"London, UK"`
+  matches 6, so the most natural phrasing for a foreign birthplace failed
+  outright. Country names now qualify via `Intl.DisplayNames` (the runtime's
+  own code→name table, so there is no list to maintain), plus colloquial
+  aliases Intl doesn't emit (`uk` → GB). Completes the class of fix started
+  for US state abbreviations in 4.11.1.
+
+### Changed
+- **Location resolver errors now carry a stable `code`.** `mcp_tool_error`
+  telemetry records no message and no stack, so every resolver rejection
+  arrived as `code: "none"` / `error_kind: "local"` — indistinguishable from
+  a genuine server-side crash. Throws now carry `location_ambiguous`,
+  `location_not_found`, `location_missing_coordinates`, `location_empty`, or
+  `coords_partial` on the property the event already ships. The codes are
+  constants; no user input is added to telemetry.
+
+---
+
 ## [4.11.1] — 2026-08-12
 
 ### Fixed

package/dist/tools/apps/_location-resolver.js

@@ -34,6 +34,31 @@ const US_STATE_ABBREVIATIONS = {
     dc: "district of columbia", pr: "puerto rico", vi: "virgin islands", gu: "guam",
     as: "american samoa", mp: "northern mariana islands",
 };
+// The API reports the country as an ISO code ("FR"), but callers type the
+// country *name* — "Paris, France" is the phrasing a model reaches for when
+// it has a foreign birthplace. Matching only the code meant that query lost
+// the qualification check against its US namesake (Paris, TX) and threw
+// ambiguous, while the far rarer "Paris, fr" resolved fine. Intl.DisplayNames
+// is the runtime's own code→name table, so there is no list to keep in sync.
+const REGION_NAMES = new Intl.DisplayNames(["en"], { type: "region" });
+function countryNameFor(code) {
+    try {
+        return String(REGION_NAMES.of(code.toUpperCase()) ?? "").toLowerCase();
+    }
+    catch {
+        return ""; // not a valid region subtag — fall through to the other checks
+    }
+}
+// Colloquial forms Intl does not produce: it renders GB as "United Kingdom",
+// so a bare "uk" token would otherwise miss.
+const COUNTRY_ALIASES = { uk: "gb", usa: "us", uae: "ae" };
+// `code` rides along to PostHog via the existing `code` property on
+// mcp_tool_error. The event deliberately records no message or stack, so
+// without a code every one of these lands as code:"none" / error_kind:"local"
+// and is indistinguishable from a genuine server-side crash.
+function codedError(code, message) {
+    return Object.assign(new Error(message), { code });
+}
 /**
  * Resolve a place name to lat/lon/tz. Throws if ambiguous or unresolvable.
  *
@@ -44,14 +69,14 @@ const US_STATE_ABBREVIATIONS = {
 export async function resolveLocationOrThrow(location) {
     const query = location.trim();
     if (query === "") {
-        throw new Error("location is empty");
+        throw codedError("location_empty", "location is empty");
     }
     const raw = (await getActiveClient().request("GET", "/location/autocomplete", {
         params: { query },
     }));
     const list = Array.isArray(raw?.suggestions) ? raw.suggestions : [];
     if (list.length === 0) {
-        throw new Error(`location "${query}" did not match any known place. Call location_search directly to inspect suggestions, ` +
+        throw codedError("location_not_found", `location "${query}" did not match any known place. Call location_search directly to inspect suggestions, ` +
             `or supply latitude/longitude explicitly.`);
     }
     const norm = (v) => String(v ?? "").trim().toLowerCase();
@@ -60,19 +85,23 @@ export async function resolveLocationOrThrow(location) {
     const q = norm(query);
     const qTokens = new Set(q.split(/[^a-z0-9]+/).filter(Boolean));
     const topRegion = norm(top.region);
+    const topCountry = norm(top.country_code);
+    const topCountryName = topCountry === "" ? "" : countryNameFor(topCountry);
     const qualified = (topRegion !== "" && q.includes(topRegion)) ||
         (topRegion !== "" && [...qTokens].some((t) => US_STATE_ABBREVIATIONS[t] === topRegion)) ||
-        (norm(top.country_code) !== "" && qTokens.has(norm(top.country_code)));
+        (topCountry !== "" && qTokens.has(topCountry)) ||
+        (topCountryName !== "" && q.includes(topCountryName)) ||
+        (topCountry !== "" && [...qTokens].some((t) => COUNTRY_ALIASES[t] === topCountry));
     const ambiguous = rivals.length > 1 && !qualified;
     if (ambiguous) {
         const options = rivals
             .slice(0, 4)
             .map((s) => `${s.display_name ?? s.short_name} (${s.country_code ?? "??"})`)
             .join("; ");
-        throw new Error(`location "${query}" is ambiguous — matches ${rivals.length} places (${options}${rivals.length > 4 ? ", …" : ""}). Call location_search directly and pass the disambiguated place, or supply latitude/longitude explicitly.`);
+        throw codedError("location_ambiguous", `location "${query}" is ambiguous — matches ${rivals.length} places (${options}${rivals.length > 4 ? ", …" : ""}). Call location_search directly and pass the disambiguated place, or supply latitude/longitude explicitly.`);
     }
     if (top.latitude == null || top.longitude == null) {
-        throw new Error(`location "${query}" matched "${top.display_name ?? top.short_name}" but the record is missing coordinates. ` +
+        throw codedError("location_missing_coordinates", `location "${query}" matched "${top.display_name ?? top.short_name}" but the record is missing coordinates. ` +
             `Supply latitude/longitude explicitly.`);
     }
     return {
@@ -101,7 +130,7 @@ export async function coordsFromArgsOrLocation(args) {
         return { latitude: lat, longitude: lon, timezone: tz, location: loc, resolvedFromLocation: false };
     }
     if (latSet !== lonSet) {
-        throw new Error("latitude and longitude must both be supplied (or both omitted with a `location` name).");
+        throw codedError("coords_partial", "latitude and longitude must both be supplied (or both omitted with a `location` name).");
     }
     if (!loc || String(loc).trim() === "") {
         // Neither coords nor location — leave undefined; the tool's own

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openephemeris/mcp-server",
-  "version": "4.11.1",
+  "version": "4.11.2",
   "description": "Model Context Protocol server for the Open Ephemeris astronomical computation API",
   "type": "module",
   "main": "dist/index.js",