@tool-bridge/server 0.21.1 → 0.23.0

package/dist/graphhopper-6OLGBDGB.js

@@ -0,0 +1,325 @@
+import {
+  createProviderHttpClient
+} from "./chunk-VWRUGUSU.js";
+import {
+  asJsonObject
+} from "./chunk-JXHMDBAY.js";
+import {
+  createProviderPlugin,
+  requireApiKey,
+  upstreamError
+} from "./chunk-WJHG6OK7.js";
+import "./chunk-2JNAI4OC.js";
+import "./chunk-BADVCN6K.js";
+import {
+  TBError
+} from "./chunk-5ICRY3VU.js";
+import "./chunk-U67V476Y.js";
+
+// ../plugins/src/graphhopper/api.ts
+var SERVICE = "graphhopper";
+var API_BASE = "https://graphhopper.com";
+var API_PREFIX = "/api/1";
+var http = createProviderHttpClient({ baseUrl: `${API_BASE}${API_PREFIX}/`, service: SERVICE });
+function text(value) {
+  return typeof value === "string" && value.trim() !== "" ? value : void 0;
+}
+function errorMessage(payload, context) {
+  if (typeof payload === "string" && payload.trim() !== "") return payload;
+  const body = asJsonObject(payload);
+  if (body !== void 0) {
+    const direct = text(body.message) ?? text(body.error) ?? text(body.details);
+    if (direct !== void 0) return direct;
+    if (Array.isArray(body.hints)) {
+      for (const hint of body.hints) {
+        const message = text(asJsonObject(hint)?.message);
+        if (message !== void 0) return message;
+      }
+    }
+  }
+  return text(context.statusText) ?? "GraphHopper request failed";
+}
+async function request(ctx, path, query) {
+  const result = await http.request({
+    path,
+    method: "GET",
+    query: [
+      ...Object.entries(query),
+      ["key", requireApiKey(ctx, SERVICE)]
+    ],
+    headers: { accept: "application/json" },
+    invalidJson: "text",
+    mapError: (context) => upstreamError(context.status, errorMessage(context.data, context)),
+    mapTransportError: ({ message }) => upstreamError(
+      502,
+      message === void 0 ? "GraphHopper request failed" : `GraphHopper request failed: ${message}`
+    )
+  });
+  return result.bodyKind === "empty" ? null : result.data;
+}
+async function calculateRoute(input, ctx) {
+  return request(ctx, "/route", {
+    "point": input.point,
+    "profile": input.profile,
+    "locale": input.locale,
+    "point_hint": input.pointHint,
+    "snap_prevention": input.snapPrevention,
+    "curbside": input.curbside,
+    "details": input.details,
+    "optimize": input.optimize,
+    "instructions": input.instructions,
+    "calc_points": input.calcPoints,
+    "points_encoded": input.pointsEncoded,
+    "elevation": input.elevation,
+    "debug": input.debug,
+    "ch.disable": input.chDisable,
+    "heading": input.heading,
+    "heading_penalty": input.headingPenalty,
+    "pass_through": input.passThrough,
+    "algorithm": input.algorithm,
+    "round_trip.distance": input.roundTripDistance,
+    "round_trip.seed": input.roundTripSeed,
+    "alternative_route.max_paths": input.alternativeRouteMaxPaths,
+    "alternative_route.max_weight_factor": input.alternativeRouteMaxWeightFactor,
+    "alternative_route.max_share_factor": input.alternativeRouteMaxShareFactor
+  });
+}
+async function geocode(input, ctx) {
+  if (input.reverse === true) {
+    if (input.point === void 0) {
+      throw new TBError("invalid_argument", "point is required when reverse is true");
+    }
+    if (input.q !== void 0) {
+      throw new TBError("invalid_argument", "q must be omitted when reverse is true");
+    }
+  } else if (input.q === void 0) {
+    throw new TBError("invalid_argument", "q is required for forward geocoding");
+  }
+  return request(ctx, "/geocode", {
+    q: input.q,
+    point: input.point,
+    reverse: input.reverse,
+    locale: input.locale,
+    limit: input.limit,
+    provider: input.provider,
+    debug: input.debug
+  });
+}
+async function computeMatrix(input, ctx) {
+  const symmetric = input.point !== void 0;
+  if (symmetric && (input.fromPoint !== void 0 || input.toPoint !== void 0)) {
+    throw new TBError("invalid_argument", "point cannot be combined with fromPoint or toPoint");
+  }
+  if (!symmetric && (input.fromPoint === void 0 || input.toPoint === void 0)) {
+    throw new TBError("invalid_argument", "provide either point or both fromPoint and toPoint");
+  }
+  return request(ctx, "/matrix", {
+    point: input.point,
+    from_point: input.fromPoint,
+    to_point: input.toPoint,
+    profile: input.profile,
+    point_hint: input.pointHint,
+    from_point_hint: input.fromPointHint,
+    to_point_hint: input.toPointHint,
+    snap_prevention: input.snapPrevention,
+    curbside: input.curbside,
+    from_curbside: input.fromCurbside,
+    to_curbside: input.toCurbside,
+    out_array: input.outArray,
+    fail_fast: input.failFast
+  });
+}
+async function computeIsochrone(input, ctx) {
+  if (input.timeLimit !== void 0 && input.distanceLimit !== void 0) {
+    throw new TBError("invalid_argument", "timeLimit and distanceLimit cannot be provided together");
+  }
+  return request(ctx, "/isochrone", {
+    point: input.point,
+    profile: input.profile,
+    time_limit: input.timeLimit,
+    distance_limit: input.distanceLimit,
+    buckets: input.buckets,
+    reverse_flow: input.reverseFlow
+  });
+}
+async function listProfiles(_input, ctx) {
+  const payload = await request(ctx, "/profiles", {});
+  if (Array.isArray(payload)) return { profiles: payload };
+  const profiles = asJsonObject(payload)?.profiles;
+  return { profiles: Array.isArray(profiles) ? profiles : [] };
+}
+
+// ../plugins/src/graphhopper/schema.ts
+import { z } from "zod/v4";
+var calculateRouteInput = z.strictObject({
+  point: z.array(z.string().min(3).describe("A coordinate string in `latitude,longitude` format.")).min(2).describe("Route waypoints in `latitude,longitude` format."),
+  profile: z.string().min(1).describe("The GraphHopper routing profile, such as `car`, `bike`, `foot`, or a custom profile id.").optional(),
+  locale: z.string().min(1).describe("The locale for turn instructions, such as `en`, `de`, or `fr`.").optional(),
+  pointHint: z.array(z.string().min(1).describe("One road name hint.")).min(1).describe("Optional road name hints for snapping each route waypoint.").optional(),
+  snapPrevention: z.array(z.string().min(1).describe("One snap prevention value such as `motorway`, `trunk`, `ferry`, `tunnel`, `bridge`, or `ford`.")).min(1).describe("Road types that should be avoided while snapping input points.").optional(),
+  curbside: z.array(z.enum(["any", "right", "left"]).describe("One curbside preference.")).describe("Curbside preferences for each route waypoint.").optional(),
+  details: z.array(z.string().min(1).describe("One GraphHopper path detail type.")).min(1).describe("Path detail types to include in the route response.").optional(),
+  optimize: z.boolean().describe("Whether GraphHopper should reorder more than two points to reduce travel time.").optional(),
+  instructions: z.boolean().describe("Whether GraphHopper should return turn-by-turn instructions.").optional(),
+  calcPoints: z.boolean().describe("Whether GraphHopper should calculate route geometry points.").optional(),
+  pointsEncoded: z.boolean().describe("Whether GraphHopper should return encoded polyline geometry.").optional(),
+  elevation: z.boolean().describe("Whether GraphHopper should include altitude as a third coordinate.").optional(),
+  debug: z.boolean().describe("Whether GraphHopper should format debug output.").optional(),
+  chDisable: z.boolean().describe("Whether to enable flexible mode for advanced routing options.").optional(),
+  heading: z.array(z.int().min(0).max(360).describe("One heading direction in degrees.")).describe("Preferred heading directions in degrees, north-based clockwise.").optional(),
+  headingPenalty: z.int().min(0).describe("The time penalty in seconds for not obeying heading.").optional(),
+  passThrough: z.boolean().describe("Whether GraphHopper should avoid u-turns at via-points.").optional(),
+  algorithm: z.enum(["round_trip", "alternative_route"]).describe("The special route algorithm to use.").optional(),
+  roundTripDistance: z.int().min(0).describe("The approximate round-trip length in meters.").optional(),
+  roundTripSeed: z.int().describe("The random seed used for deterministic round-trip results.").optional(),
+  alternativeRouteMaxPaths: z.int().min(1).describe("The maximum number of alternative routes.").optional(),
+  alternativeRouteMaxWeightFactor: z.number().min(0).describe("The maximum factor by which alternative routes may be longer than the optimal route.").optional(),
+  alternativeRouteMaxShareFactor: z.number().min(0).max(1).describe("The maximum similarity factor between an alternative route and the optimal route.").optional()
+}).describe("Input parameters for calculating a GraphHopper route.");
+var calculateRouteOutput = z.looseObject({
+  paths: z.array(z.looseObject({
+    distance: z.number().describe("The total route distance in meters.").optional(),
+    time: z.int().describe("The total route travel time in milliseconds.").optional(),
+    ascend: z.number().describe("The total ascent in meters.").optional(),
+    descend: z.number().describe("The total descent in meters.").optional(),
+    points: z.unknown().describe("The route geometry, either encoded or a coordinate object.").optional(),
+    snapped_waypoints: z.unknown().describe("The snapped input waypoints, either encoded or a coordinate object.").optional(),
+    points_encoded: z.boolean().describe("Whether route geometry fields use encoded polyline strings.").optional(),
+    bbox: z.array(z.number().describe("One bounding box coordinate.")).describe("The route bounding box as `[minLon, minLat, maxLon, maxLat]`.").optional(),
+    instructions: z.array(z.looseObject({}).describe("An upstream GraphHopper object returned as-is.")).describe("The turn-by-turn route instructions returned by GraphHopper.").optional(),
+    details: z.looseObject({}).describe("Path details keyed by requested detail type.").optional(),
+    points_order: z.array(z.int().describe("One zero-based input point index.")).describe("The optimized visit order when route optimization was requested.").optional()
+  }).describe("One route path returned by GraphHopper.")).describe("The calculated route paths.").optional(),
+  info: z.looseObject({
+    copyrights: z.array(z.string().describe("One notice.")).describe("The copyright notices returned by GraphHopper.").optional(),
+    took: z.number().describe("The time GraphHopper spent processing the request.").optional()
+  }).describe("Additional GraphHopper response metadata.").optional()
+}).describe("The route response returned by GraphHopper.");
+var geocodeInput = z.strictObject({
+  q: z.string().min(1).describe("The textual address or place query for forward geocoding.").optional(),
+  point: z.string().min(1).describe("The `latitude,longitude` location bias for forward geocoding or target coordinate for reverse geocoding.").optional(),
+  reverse: z.boolean().describe("Whether to perform reverse geocoding. When true, point is required and q must be omitted.").optional(),
+  locale: z.string().min(1).describe("The locale used for localized geocoding results.").optional(),
+  limit: z.int().min(1).describe("The maximum number of geocoding results to return.").optional(),
+  provider: z.string().min(1).describe("The GraphHopper geocoding provider, such as `default`, `nominatim`, `gisgraphy`, or `opencagedata`.").optional(),
+  debug: z.boolean().describe("Whether GraphHopper should format debug output.").optional()
+}).describe("Input parameters for forward or reverse geocoding with GraphHopper.");
+var geocodeOutput = z.looseObject({
+  hits: z.array(z.looseObject({
+    point: z.strictObject({
+      lat: z.number().describe("The latitude coordinate.").optional(),
+      lng: z.number().describe("The longitude coordinate.").optional()
+    }).describe("A latitude and longitude point returned by GraphHopper.").optional(),
+    osm_id: z.int().describe("The OpenStreetMap entity id.").optional(),
+    osm_type: z.string().describe("The OpenStreetMap entity type.").optional(),
+    osm_key: z.string().describe("The OpenStreetMap key.").optional(),
+    osm_value: z.string().describe("The OpenStreetMap value.").optional(),
+    name: z.string().describe("The matched place, address, or entity name.").optional(),
+    country: z.string().describe("The country of the result.").optional(),
+    city: z.string().describe("The city of the result.").optional(),
+    state: z.string().describe("The state or region of the result.").optional(),
+    street: z.string().describe("The street of the result.").optional(),
+    housenumber: z.string().describe("The house number of the result.").optional(),
+    postcode: z.string().describe("The postal code of the result.").optional()
+  }).describe("One geocoding hit returned by GraphHopper.")).describe("The geocoding candidates returned by GraphHopper.").optional(),
+  took: z.number().describe("The time GraphHopper spent processing the geocoding request in milliseconds.").optional()
+}).describe("The geocoding response returned by GraphHopper.");
+var computeMatrixInput = z.strictObject({
+  point: z.array(z.string().min(3).describe("A coordinate string in `latitude,longitude` format.")).min(3).describe("Points in `latitude,longitude` format used as both origins and destinations.").optional(),
+  fromPoint: z.array(z.string().min(3).describe("A coordinate string in `latitude,longitude` format.")).min(1).describe("Origin points in `latitude,longitude` format.").optional(),
+  toPoint: z.array(z.string().min(3).describe("A coordinate string in `latitude,longitude` format.")).min(1).describe("Destination points in `latitude,longitude` format.").optional(),
+  profile: z.string().min(1).describe("The GraphHopper routing profile, such as `car`, `bike`, `foot`, or a custom profile id.").optional(),
+  pointHint: z.array(z.string().min(1).describe("One point hint.")).min(1).describe("Hints for point entries.").optional(),
+  fromPointHint: z.array(z.string().min(1).describe("One origin point hint.")).min(1).describe("Hints for origin points.").optional(),
+  toPointHint: z.array(z.string().min(1).describe("One destination point hint.")).min(1).describe("Hints for destination points.").optional(),
+  snapPrevention: z.array(z.string().min(1).describe("One snap prevention value.")).min(1).describe("Road types that should be avoided while snapping matrix points.").optional(),
+  curbside: z.array(z.enum(["any", "right", "left"]).describe("One curbside preference.")).describe("Curbside preferences for point entries.").optional(),
+  fromCurbside: z.array(z.enum(["any", "right", "left"]).describe("One curbside preference.")).describe("Curbside preferences for origin points.").optional(),
+  toCurbside: z.array(z.enum(["any", "right", "left"]).describe("One curbside preference.")).describe("Curbside preferences for destination points.").optional(),
+  outArray: z.array(z.enum(["weights", "times", "distances"]).describe("One matrix output array name.")).min(1).describe("Matrix arrays to include in the response.").optional(),
+  failFast: z.boolean().describe("Whether GraphHopper should fail immediately when points cannot be resolved.").optional()
+}).describe("Input parameters for computing a synchronous GraphHopper matrix.");
+var computeMatrixOutput = z.looseObject({
+  distances: z.array(z.array(z.number().describe("One matrix value, or null when the route could not be calculated.").nullable()).describe("One matrix row.")).describe("A GraphHopper matrix of numeric values or null entries.").optional(),
+  times: z.array(z.array(z.number().describe("One matrix value, or null when the route could not be calculated.").nullable()).describe("One matrix row.")).describe("A GraphHopper matrix of numeric values or null entries.").optional(),
+  weights: z.array(z.array(z.number().describe("One matrix value, or null when the route could not be calculated.").nullable()).describe("One matrix row.")).describe("A GraphHopper matrix of numeric values or null entries.").optional(),
+  info: z.looseObject({
+    copyrights: z.array(z.string().describe("One notice.")).describe("The copyright notices returned by GraphHopper.").optional(),
+    took: z.number().describe("The time GraphHopper spent processing the request.").optional()
+  }).describe("Additional GraphHopper response metadata.").optional(),
+  hints: z.array(z.looseObject({}).describe("An upstream GraphHopper object returned as-is.")).describe("Additional GraphHopper matrix hints.").optional()
+}).describe("The matrix response returned by GraphHopper.");
+var computeIsochroneInput = z.strictObject({
+  point: z.string().min(3).describe("A coordinate string in `latitude,longitude` format."),
+  profile: z.string().min(1).describe("The GraphHopper routing profile, such as `car`, `bike`, `foot`, or a custom profile id.").optional(),
+  timeLimit: z.int().min(1).describe("The travel time limit in seconds.").optional(),
+  distanceLimit: z.int().min(1).describe("The travel distance limit in meters.").optional(),
+  buckets: z.int().min(1).describe("The number of nested isochrone buckets to return.").optional(),
+  reverseFlow: z.boolean().describe("Whether the flow should go from polygons toward the point.").optional()
+}).describe("Input parameters for computing GraphHopper isochrone polygons.");
+var computeIsochroneOutput = z.looseObject({
+  polygons: z.array(z.looseObject({}).describe("An upstream GraphHopper object returned as-is.")).describe("The GeoJSON isochrone polygons returned by GraphHopper.").optional()
+}).describe("The isochrone response returned by GraphHopper.");
+var listProfilesInput = z.strictObject({}).describe("Input parameters for listing GraphHopper custom profiles.");
+var listProfilesOutput = z.strictObject({
+  profiles: z.array(z.looseObject({
+    id: z.string().describe("The custom profile id.").optional(),
+    profile: z.string().describe("The built-in routing profile this custom profile is based on.").optional(),
+    bounds: z.looseObject({}).describe("The geographic bounds where this custom profile can be used.").optional(),
+    custom_model: z.looseObject({}).describe("The custom model definition for this profile.").optional()
+  }).describe("One custom GraphHopper routing profile.")).describe("The available custom routing profiles.").optional()
+}).describe("The custom routing profiles returned by GraphHopper.");
+var graphhopperActions = {
+  calculate_route: {
+    description: "Calculate the best route connecting two or more coordinates with the GraphHopper Routing API.",
+    effect: "write",
+    inputSchema: calculateRouteInput,
+    outputSchema: z.toJSONSchema(calculateRouteOutput, { io: "output", unrepresentable: "any" })
+  },
+  geocode: {
+    description: "Convert text to coordinates or coordinates to place candidates with the GraphHopper Geocoding API.",
+    effect: "write",
+    inputSchema: geocodeInput,
+    outputSchema: z.toJSONSchema(geocodeOutput, { io: "output", unrepresentable: "any" })
+  },
+  compute_matrix: {
+    description: "Compute a synchronous travel time, distance, or weight matrix with the GraphHopper Matrix API.",
+    effect: "write",
+    inputSchema: computeMatrixInput,
+    outputSchema: z.toJSONSchema(computeMatrixOutput, { io: "output", unrepresentable: "any" })
+  },
+  compute_isochrone: {
+    description: "Compute GeoJSON isochrone polygons around a coordinate with the GraphHopper Isochrone API.",
+    effect: "write",
+    inputSchema: computeIsochroneInput,
+    outputSchema: z.toJSONSchema(computeIsochroneOutput, { io: "output", unrepresentable: "any" })
+  },
+  list_profiles: {
+    description: "List custom routing profiles available to the GraphHopper API key.",
+    effect: "read",
+    inputSchema: listProfilesInput,
+    outputSchema: z.toJSONSchema(listProfilesOutput, { io: "output", unrepresentable: "any" })
+  }
+};
+
+// ../plugins/src/graphhopper/index.ts
+function createGraphhopperPlugin() {
+  return createProviderPlugin({
+    description: "GraphHopper",
+    actions: graphhopperActions,
+    // 上游 credentialValidators 打的就是 /profiles;它是唯一只读、无必填入参且不消耗路径配额的调用。
+    credentialProbe: "list_profiles",
+    handlers: {
+      calculate_route: calculateRoute,
+      geocode,
+      compute_matrix: computeMatrix,
+      compute_isochrone: computeIsochrone,
+      list_profiles: listProfiles
+    }
+  });
+}
+var graphhopper_default = createGraphhopperPlugin();
+export {
+  createGraphhopperPlugin,
+  graphhopper_default as default
+};