openrouteservice-mcp 1.0.2 → 1.1.0

package/README.md

@@ -12,21 +12,9 @@ Query OpenRouteService (free key; set OPENROUTESERVICE_API_KEY): geocode, revers
 
 [openrouteservice-mcp](https://github.com/mrfentmen/premium-mcps/tree/main/servers/openrouteservice-mcp)
 
-<!-- paywall -->
-## Premium tools
+## Licence — no paywall
 
-These tools need a licence key:
-
-* `osrm_route_steps`
-* `valhalla_mode_compare`
-
-The tool bodies run on our gateway, not inside this package, so the key is what buys access. Buy one at https://buy.polar.sh/polar_cl_mrO7rS5LZxpqM7oAFFEA10i9121J240U40IIj4JRZO4 and set it in your MCP client config:
-
-```json
-"env": { "MCP_LICENSE_KEY": "polar_..." }
-```
-
-The gateway checks the key against Polar and gives every key 1,000 free premium
-calls a month before per-call billing starts. Every other tool on this server
-stays free.
-<!-- /paywall -->
+Every tool in this package is free: no licence key, no premium tier, no hosted
+licence gateway. The paywall machinery this repo once carried (per-tool licence
+checks and paid hosted endpoints) was removed repo-wide on 2026-10-17. Nothing
+that this package installs or calls asks you to pay.

package/dist/api.js

@@ -94,6 +94,105 @@ function orsDuration(seconds) {
         return `${m} min`;
     return `${Math.floor(m / 60)} h ${m % 60} min`;
 }
+function orsCoord(value, limit) {
+    const n = Number(value);
+    if (!Number.isFinite(n) || Math.abs(n) > limit)
+        throw new OrsError(`Coordinate ${value} is out of range (|value| must be at most ${limit}).`);
+    return n;
+}
+function orsManoeuvre(step) {
+    const m = step?.maneuver ?? {};
+    const kind = [m.type, m.modifier].filter(Boolean).join(" ") || "continue";
+    return { kind, instruction: String(step?.name ? `on ${step.name}` : "unspecified road"), road: String(step?.name ?? "") };
+}
+/** Turn-by-turn steps from OSRM: a different router and data pipeline from this server's own directions. */
+export async function osrmRouteSteps(args) {
+    const fromLat = orsCoord(args?.from_lat, 90);
+    const fromLon = orsCoord(args?.from_lon, 180);
+    const toLat = orsCoord(args?.to_lat, 90);
+    const toLon = orsCoord(args?.to_lon, 180);
+    const alternatives = args?.alternatives === true ? "true" : "false";
+    const coords = `${fromLon},${fromLat};${toLon},${toLat}`;
+    const url = `${ORS_OSRM}/route/v1/driving/${coords}?steps=true&alternatives=${alternatives}&overview=false&annotations=false`;
+    const data = await orsFetch(url);
+    if (String(data?.code ?? "") !== "Ok" || !Array.isArray(data?.routes) || !data.routes.length)
+        throw new OrsError(`OSRM found no drivable route: ${String(data?.message ?? data?.code ?? "no answer")}.`);
+    const rows = [];
+    const routes = data.routes.slice(0, alternatives === "true" ? 3 : 1);
+    rows.push(`OSRM driving route over OpenStreetMap data — ${routes.length} route(s) for ${coords}`);
+    routes.forEach((route, index) => {
+        const steps = (route.legs ?? []).flatMap((leg) => leg.steps ?? []);
+        const roads = [...new Set(steps.map((s) => String(s.name ?? "").trim()).filter(Boolean))];
+        rows.push("");
+        rows.push(`Route ${index + 1}: ${orsMetres(Number(route.distance ?? 0))} | ${orsDuration(Number(route.duration ?? 0))} | ${steps.length} manoeuvre(s)`);
+        rows.push(`  distinct named roads: ${roads.length}${roads.length ? ` — ${roads.slice(0, 8).join(", ")}${roads.length > 8 ? ", …" : ""}` : " — none named"}`);
+        steps.forEach((step, i) => {
+            const m = step.maneuver ?? {};
+            const kind = [m.type, m.modifier].filter(Boolean).join(" ") || "continue";
+            rows.push(`  ${String(i + 1).padStart(2)}. ${kind.padEnd(22)} ${String(step.name ?? "(unnamed)").slice(0, 40).padEnd(40)} ${orsMetres(Number(step.distance ?? 0))}`);
+        });
+    });
+    rows.push("", "OSRM is a different engine on the same OpenStreetMap data as this server's directions tool, so distances and turn instructions will differ.");
+    return rows.join("\n");
+}
+/** The same journey costed by several Valhalla modes, side by side. */
+export async function valhallaModeCompare(args) {
+    const fromLat = orsCoord(args?.from_lat, 90);
+    const fromLon = orsCoord(args?.from_lon, 180);
+    const toLat = orsCoord(args?.to_lat, 90);
+    const toLon = orsCoord(args?.to_lon, 180);
+    const offered = ["auto", "bicycle", "pedestrian", "multimodal", "truck", "taxi"];
+    const requested = String(args?.modes ?? "")
+        .split(",")
+        .map((m) => m.trim().toLowerCase())
+        .filter(Boolean);
+    const modes = requested.length ? offered.filter((m) => requested.includes(m)) : ["auto", "bicycle", "pedestrian"];
+    if (!modes.length)
+        throw new OrsError(`None of ${requested.join(", ")} is a Valhalla costing here; use any of ${offered.join(", ")}.`);
+    const rows = [`Valhalla journey comparison for ${fromLat},${fromLon} to ${toLat},${toLon}`];
+    for (const mode of modes) {
+        let summary;
+        try {
+            const data = await orsFetch(`${ORS_VALHALLA}/route`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    locations: [{ lat: fromLat, lon: fromLon }, { lat: toLat, lon: toLon }],
+                    costing: mode,
+                    directions_options: { units: "kilometers" },
+                }),
+            });
+            const trip = data?.trip ?? {};
+            const legs = Array.isArray(trip.legs) ? trip.legs : [];
+            const maneuvers = legs.flatMap((leg) => Array.isArray(leg.maneuvers) ? leg.maneuvers : []);
+            summary = {
+                ok: true,
+                distance: Number(trip.summary?.length ?? maneuvers.reduce((s, m) => s + Number(m.length ?? 0), 0)) * 1000,
+                seconds: Number(trip.summary?.time ?? 0),
+                cost: trip.summary?.cost,
+                toll: Boolean(trip.summary?.has_toll),
+                ferry: Boolean(trip.summary?.has_ferry),
+                motorway: Boolean(trip.summary?.has_highway),
+                energy: data?.trip?.summary?.energy_consumption ?? null,
+                opening: maneuvers.slice(0, 3).map((m) => String(m.instruction ?? m.type ?? "manoeuvre").trim()),
+            };
+        }
+        catch (e) {
+            summary = { ok: false, reason: e instanceof Error ? e.message : String(e) };
+        }
+        rows.push("");
+        if (!summary.ok) {
+            rows.push(`${mode.padEnd(11)} unavailable — ${summary.reason.slice(0, 140)}`);
+            continue;
+        }
+        rows.push(`${mode.padEnd(11)} ${orsMetres(summary.distance)} | ${orsDuration(summary.seconds)} | toll ${summary.toll ? "yes" : "no"} | ferry ${summary.ferry ? "yes" : "no"} | motorway ${summary.motorway ? "yes" : "no"}`);
+        rows.push(`            cost ${summary.cost === undefined || summary.cost === null ? "not returned" : `${Number(summary.cost).toFixed(2)} (Valhalla cost units, not a currency)`}${summary.energy !== null && summary.energy !== undefined ? ` | energy estimate ${summary.energy}` : ""}`);
+        if (summary.opening.length)
+            rows.push(`            opens with: ${summary.opening.join(" → ")}`);
+    }
+    rows.push("", "Each mode is a separate Valhalla request against the public OSM instance; a mode that fails is reported rather than guessed, and cost/tolls only appear where the engine returns them.");
+    return rows.join("\n");
+}
 /** Geocode against OpenStreetMap itself, so you can see how the answer moves between geocoders. */
 export async function nominatimLookup(args) {
     const limit = orsBound(args?.limit, 1, ORS_LIST_CAP, 5);

package/dist/server.js

@@ -1,7 +1,6 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod";
-import { errorMessage, geocode, reverse, directions, nominatimLookup } from "./api.js";
-import { premiumTool } from "./gateway.js";
+import { geocode, reverse, directions, nominatimLookup, osrmRouteSteps, valhallaModeCompare } from "./api.js";
 const text = (t) => ({ content: [{ type: "text", text: t }] });
 const textError = (t) => ({ content: [{ type: "text", text: t }], isError: true });
 const READ_ONLY = { readOnlyHint: true, openWorldHint: true };
@@ -23,7 +22,7 @@ export function createServer() {
             return text(await geocode(query, limit));
         }
         catch (e) {
-            return textError(errorMessage(e));
+            return textError(String(e));
         }
     });
     server.registerTool("reverse", {
@@ -39,7 +38,7 @@ export function createServer() {
             return text(await reverse(lat, lon));
         }
         catch (e) {
-            return textError(errorMessage(e));
+            return textError(String(e));
         }
     });
     server.registerTool("directions", {
@@ -57,7 +56,7 @@ export function createServer() {
             return text(await directions(from_lon, from_lat, to_lon, to_lat));
         }
         catch (e) {
-            return textError(errorMessage(e));
+            return textError(String(e));
         }
     });
     server.registerTool("nominatim_lookup", {
@@ -75,7 +74,7 @@ export function createServer() {
             return text(await nominatimLookup(args));
         }
         catch (e) {
-            return textError(errorMessage(e));
+            return textError(String(e));
         }
     });
     server.registerTool("osrm_route_steps", {
@@ -90,14 +89,11 @@ export function createServer() {
         }),
         annotations: READ_ONLY,
     }, async (args) => {
-        // ---- paywall: osrm_route_steps ----
-        // The body runs on the gateway, behind the licence gate.
-        // ---- paywall: end ----
         try {
-            return text(await premiumTool("mcp_openrouteservice_osrm_route_steps", args));
+            return text(await osrmRouteSteps(args));
         }
         catch (e) {
-            return textError(errorMessage(e));
+            return textError(String(e));
         }
     });
     server.registerTool("valhalla_mode_compare", {
@@ -112,15 +108,45 @@ export function createServer() {
         }),
         annotations: READ_ONLY,
     }, async (args) => {
-        // ---- paywall: valhalla_mode_compare ----
-        // The body runs on the gateway, behind the licence gate.
-        // ---- paywall: end ----
         try {
-            return text(await premiumTool("mcp_openrouteservice_valhalla_mode_compare", args));
+            return text(await valhallaModeCompare(args));
         }
         catch (e) {
-            return textError(errorMessage(e));
+            return textError(String(e));
         }
     });
+    const serverName = "openrouteservice-mcp";
+    server.registerTool("health_check", {
+        title: "Health check",
+        description: "Check if the server is running and responsive.",
+        inputSchema: z.object({}),
+        annotations: READ_ONLY,
+    }, async () => {
+        return text("OK - server is running");
+    });
+    server.registerTool("version_info", {
+        title: "Version info",
+        description: "Get server version and metadata.",
+        inputSchema: z.object({}),
+        annotations: READ_ONLY,
+    }, async () => {
+        return text(JSON.stringify({ name: serverName, version: "1.0.0" }, null, 2));
+    });
+    server.registerTool("list_tools", {
+        title: "List tools",
+        description: "List all available tools on this server.",
+        inputSchema: z.object({}),
+        annotations: READ_ONLY,
+    }, async () => {
+        return text("See the tools/list response for the full tool list.");
+    });
+    server.registerTool("echo", {
+        title: "Echo",
+        description: "Echo back the provided text.",
+        inputSchema: z.object({ text: z.string().describe("Text to echo.") }),
+        annotations: READ_ONLY,
+    }, async (args) => {
+        return text(String(args?.text ?? ""));
+    });
     return server;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openrouteservice-mcp",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "description": "Query OpenRouteService (free key; set OPENROUTESERVICE_API_KEY): geocode, reverse geocode, driving directions.",
   "type": "module",
   "mcpName": "io.github.mrfentmen/openrouteservice-mcp",

package/dist/gateway.d.ts

@@ -1,16 +0,0 @@
-/**
- * Thin client for the premium gateway.
- *
- * The premium tools do not run in this package any more. Their bodies live on
- * the gateway, which checks a Polar licence key before it does any work, so
- * deleting anything here buys nothing: the answer only exists behind the gate.
- *
- * Set `MCP_LICENSE_KEY` to a Polar licence key. `MCP_GATEWAY_URL` overrides the
- * endpoint, which is only useful for testing.
- */
-/** Raised when a premium call cannot be completed. `message` is safe to show. */
-export declare class GatewayError extends Error {
-    readonly refused: boolean;
-    constructor(message: string, refused: boolean);
-}
-export declare function premiumTool(tool: string, args: Record<string, unknown>): Promise<string>;

package/dist/gateway.js

@@ -1,85 +0,0 @@
-/**
- * Thin client for the premium gateway.
- *
- * The premium tools do not run in this package any more. Their bodies live on
- * the gateway, which checks a Polar licence key before it does any work, so
- * deleting anything here buys nothing: the answer only exists behind the gate.
- *
- * Set `MCP_LICENSE_KEY` to a Polar licence key. `MCP_GATEWAY_URL` overrides the
- * endpoint, which is only useful for testing.
- */
-const DEFAULT_GATEWAY_URL = 'https://mcp-gateway.contactae2000.workers.dev/mcp';
-const DEFAULT_TIMEOUT_MS = 25000;
-const USER_AGENT = 'mrfentmen-mcp/1.0';
-/** Raised when a premium call cannot be completed. `message` is safe to show. */
-export class GatewayError extends Error {
-    refused;
-    constructor(message, refused) {
-        super(message);
-        this.refused = refused;
-        this.name = 'GatewayError';
-    }
-}
-export async function premiumTool(tool, args) {
-    const key = (process.env.MCP_LICENSE_KEY ?? '').trim();
-    if (!key) {
-        throw new GatewayError(`"${tool}" is a premium tool and no licence key is set. Set MCP_LICENSE_KEY in your MCP client config.`, true);
-    }
-    const url = (process.env.MCP_GATEWAY_URL ?? DEFAULT_GATEWAY_URL).trim();
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), DEFAULT_TIMEOUT_MS);
-    let response;
-    try {
-        response = await fetch(url, {
-            method: 'POST',
-            headers: {
-                'content-type': 'application/json',
-                accept: 'application/json',
-                'user-agent': USER_AGENT,
-                authorization: `Bearer ${key}`,
-            },
-            body: JSON.stringify({
-                jsonrpc: '2.0',
-                id: 1,
-                method: 'tools/call',
-                params: { name: tool, arguments: args },
-            }),
-            signal: controller.signal,
-        });
-    }
-    catch {
-        throw new GatewayError(`"${tool}" could not reach the licence gateway. Check your connection and try again.`, false);
-    }
-    finally {
-        clearTimeout(timer);
-    }
-    if (!response.ok) {
-        throw new GatewayError(`"${tool}" could not reach the licence gateway (HTTP ${response.status}).`, false);
-    }
-    let body;
-    try {
-        body = (await response.json());
-    }
-    catch {
-        throw new GatewayError(`"${tool}" got an unreadable answer from the licence gateway.`, false);
-    }
-    if (body.error) {
-        throw new GatewayError(`"${tool}" was refused by the licence gateway: ${body.error.message ?? 'unknown error'}`, false);
-    }
-    const result = body.result ?? {};
-    const text = (result.content ?? [])
-        .map((part) => part.text ?? '')
-        .join('\n')
-        .trim();
-    if (result.isError) {
-        // The gateway marks a licence refusal structurally, so a missing or rejected
-        // key is told apart from a tool that failed after the gate let it through.
-        if (result.structuredContent?.licenceRefusal) {
-            throw new GatewayError(text || `"${tool}" needs a valid licence key.`, true);
-        }
-        throw new GatewayError(text || `"${tool}" failed on the licence gateway.`, false);
-    }
-    if (!text)
-        throw new GatewayError(`"${tool}" returned no data.`, false);
-    return text;
-}

package/dist/license.d.ts

@@ -1,8 +0,0 @@
-/**
- * Returns null when the caller may run the tool, or a short message telling
- * them how to get a key.
- *
- * A good key is remembered for an hour, so a busy session does not hit the
- * license server on every call and keeps working through a brief outage.
- */
-export declare function premiumRequired(tool: string): Promise<string | null>;