MapMap

{
  "type": "object",
  "$defs": {
    "LatLon": {
      "anyOf": [
        {
          "type": "object",
          "required": [
            "lat",
            "lon"
          ],
          "properties": {
            "lat": {
              "type": "number",
              "format": "double",
              "description": "Latitude in decimal degrees (−90 to 90)."
            },
            "lon": {
              "type": "number",
              "format": "double",
              "description": "Longitude in decimal degrees (−180 to 180)."
            }
          }
        },
        {
          "type": "array",
          "items": {
            "type": "number",
            "format": "double"
          },
          "maxItems": 2,
          "minItems": 2,
          "description": "GeoJSON position [lon, lat]: longitude FIRST."
        }
      ],
      "description": "A WGS84 coordinate in decimal degrees: a {lat, lon} object (preferred), or a GeoJSON [lon, lat] array with LONGITUDE FIRST, the same order as every polygon field on this server."
    },
    "TruckSpec": {
      "type": "object",
      "properties": {
        "hazmat": {
          "type": "boolean",
          "default": false,
          "description": "Whether the vehicle carries dangerous goods (ADR). Defaults to\nfalse."
        },
        "width_m": {
          "type": [
            "number",
            "null"
          ],
          "format": "double",
          "description": "Vehicle width in metres."
        },
        "height_m": {
          "type": [
            "number",
            "null"
          ],
          "format": "double",
          "description": "Vehicle height in metres."
        },
        "length_m": {
          "type": [
            "number",
            "null"
          ],
          "format": "double",
          "description": "Vehicle length in metres."
        },
        "tunnel_code": {
          "type": [
            "string",
            "null"
          ],
          "description": "ADR 8.6.4 tunnel restriction code of the load, e.g. \"B\", \"C5000D\",\n\"B/D\", or \"(-)\"/\"none\" for explicitly unrestricted. Leave unset if\nunknown: a hazmat load without a code is conservatively treated as\ncode B (allowed only through category-A tunnels)."
        },
        "gross_weight_t": {
          "type": [
            "number",
            "null"
          ],
          "format": "double",
          "description": "Gross combination weight in metric tonnes."
        }
      },
      "description": "Truck profile for routing: physical dimensions plus the ADR\ndangerous-goods declaration. Omitted dimensions default to the EU\nmaximum authorised dimensions of Council Directive 96/53/EC (4.0 m\nheight, 2.55 m width, 16.5 m length, 40 t gross weight)."
    },
    "CostingKind": {
      "oneOf": [
        {
          "type": "string",
          "const": "auto",
          "description": "Standard car costing."
        },
        {
          "type": "string",
          "const": "truck",
          "description": "Truck costing; honours dimensional limits and, when a `truck`\nprofile is supplied, ADR dangerous-goods restrictions."
        },
        {
          "type": "string",
          "const": "bicycle",
          "description": "Bicycle costing; tune it with a `bicycle` options object."
        },
        {
          "type": "string",
          "const": "pedestrian",
          "description": "Pedestrian (walking) costing; tune it with a `pedestrian` options\nobject (lit streets, wheelchair/blind, hiking difficulty)."
        },
        {
          "type": "string",
          "const": "motor_scooter",
          "description": "Motor scooter (moped) costing: like auto but prefers lower-speed\nroads and may use ways closed to larger motor vehicles."
        }
      ],
      "description": "Costing models exposed by the MCP tools (a deliberate subset of the\nValhalla costing list), serialised in snake_case exactly as Valhalla\nnames them."
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "truck": {
      "anyOf": [
        {
          "$ref": "#/$defs/TruckSpec"
        },
        {
          "type": "null"
        }
      ],
      "description": "Truck profile (dimensions + ADR declaration). Requires costing\n\"truck\"; the detours then respect dimensional/ADR restrictions."
    },
    "min_kw": {
      "type": [
        "number",
        "null"
      ],
      "format": "double",
      "description": "Keep only charge points whose best connector is rated at least this\nmany kW (e.g. 50 for rapid charging only)."
    },
    "origin": {
      "anyOf": [
        {
          "$ref": "#/$defs/LatLon"
        },
        {
          "type": "null"
        }
      ],
      "description": "Route origin (with `destination`, when no geometry is given)."
    },
    "costing": {
      "$ref": "#/$defs/CostingKind",
      "default": "auto",
      "description": "Costing model for the route and detour matrix: \"auto\" (default),\n\"truck\", \"bicycle\", \"pedestrian\" or \"motor_scooter\"."
    },
    "connectors": {
      "type": [
        "array",
        "null"
      ],
      "items": {
        "type": "string"
      },
      "description": "Keep only charge points offering at least one of these connector\nstandards: \"type2\", \"type1\", \"ccs\", \"chademo\", \"tesla\", \"domestic\"\nor \"other\". Omitted ⇒ every standard."
    },
    "destination": {
      "anyOf": [
        {
          "$ref": "#/$defs/LatLon"
        },
        {
          "type": "null"
        }
      ],
      "description": "Route destination."
    },
    "max_results": {
      "type": [
        "integer",
        "null"
      ],
      "format": "uint32",
      "minimum": 0,
      "description": "Maximum results (default 5, at most 25)."
    },
    "available_only": {
      "type": [
        "boolean",
        "null"
      ],
      "description": "Keep only charge points with a bay reported free right now. Needs\nthe deployment to have a live availability feed; without one the\ncall is refused rather than silently returning nothing."
    },
    "geometry_polyline6": {
      "type": [
        "string",
        "null"
      ],
      "description": "An existing route geometry as an encoded polyline6 (the `route`\ntool's `geometry_polyline6`). Provide either this or `origin` +\n`destination`, not both."
    },
    "max_detour_minutes": {
      "type": [
        "number",
        "null"
      ],
      "format": "double",
      "description": "Largest acceptable detour in minutes (default 10, at most 120)."
    }
  }
}

{
  "type": "object",
  "$defs": {
    "LatLon": {
      "anyOf": [
        {
          "type": "object",
          "required": [
            "lat",
            "lon"
          ],
          "properties": {
            "lat": {
              "type": "number",
              "format": "double",
              "description": "Latitude in decimal degrees (−90 to 90)."
            },
            "lon": {
              "type": "number",
              "format": "double",
              "description": "Longitude in decimal degrees (−180 to 180)."
            }
          }
        },
        {
          "type": "array",
          "items": {
            "type": "number",
            "format": "double"
          },
          "maxItems": 2,
          "minItems": 2,
          "description": "GeoJSON position [lon, lat]: longitude FIRST."
        }
      ],
      "description": "A WGS84 coordinate in decimal degrees: a {lat, lon} object (preferred), or a GeoJSON [lon, lat] array with LONGITUDE FIRST, the same order as every polygon field on this server."
    },
    "TruckSpec": {
      "type": "object",
      "properties": {
        "hazmat": {
          "type": "boolean",
          "default": false,
          "description": "Whether the vehicle carries dangerous goods (ADR). Defaults to\nfalse."
        },
        "width_m": {
          "type": [
            "number",
            "null"
          ],
          "format": "double",
          "description": "Vehicle width in metres."
        },
        "height_m": {
          "type": [
            "number",
            "null"
          ],
          "format": "double",
          "description": "Vehicle height in metres."
        },
        "length_m": {
          "type": [
            "number",
            "null"
          ],
          "format": "double",
          "description": "Vehicle length in metres."
        },
        "tunnel_code": {
          "type": [
            "string",
            "null"
          ],
          "description": "ADR 8.6.4 tunnel restriction code of the load, e.g. \"B\", \"C5000D\",\n\"B/D\", or \"(-)\"/\"none\" for explicitly unrestricted. Leave unset if\nunknown: a hazmat load without a code is conservatively treated as\ncode B (allowed only through category-A tunnels)."
        },
        "gross_weight_t": {
          "type": [
            "number",
            "null"
          ],
          "format": "double",
          "description": "Gross combination weight in metric tonnes."
        }
      },
      "description": "Truck profile for routing: physical dimensions plus the ADR\ndangerous-goods declaration. Omitted dimensions default to the EU\nmaximum authorised dimensions of Council Directive 96/53/EC (4.0 m\nheight, 2.55 m width, 16.5 m length, 40 t gross weight)."
    },
    "CostingKind": {
      "oneOf": [
        {
          "type": "string",
          "const": "auto",
          "description": "Standard car costing."
        },
        {
          "type": "string",
          "const": "truck",
          "description": "Truck costing; honours dimensional limits and, when a `truck`\nprofile is supplied, ADR dangerous-goods restrictions."
        },
        {
          "type": "string",
          "const": "bicycle",
          "description": "Bicycle costing; tune it with a `bicycle` options object."
        },
        {
          "type": "string",
          "const": "pedestrian",
          "description": "Pedestrian (walking) costing; tune it with a `pedestrian` options\nobject (lit streets, wheelchair/blind, hiking difficulty)."
        },
        {
          "type": "string",
          "const": "motor_scooter",
          "description": "Motor scooter (moped) costing: like auto but prefers lower-speed\nroads and may use ways closed to larger motor vehicles."
        }
      ],
      "description": "Costing models exposed by the MCP tools (a deliberate subset of the\nValhalla costing list), serialised in snake_case exactly as Valhalla\nnames them."
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "fuel": {
      "type": [
        "string",
        "null"
      ],
      "description": "Which fuel to price: \"diesel\" (default), \"petrol_95\", \"petrol_98\",\n\"premium_diesel\", \"e85\" or \"lpg\" (aliases \"petrol\", \"unleaded\",\n\"e10\", \"super_unleaded\", \"e5\", \"b7\" and \"sdv\" are accepted)."
    },
    "truck": {
      "anyOf": [
        {
          "$ref": "#/$defs/TruckSpec"
        },
        {
          "type": "null"
        }
      ],
      "description": "Truck profile (dimensions + ADR declaration). Requires costing\n\"truck\"; the detours then respect dimensional/ADR restrictions."
    },
    "origin": {
      "anyOf": [
        {
          "$ref": "#/$defs/LatLon"
        },
        {
          "type": "null"
        }
      ],
      "description": "Route origin (with `destination`, when no geometry is given)."
    },
    "costing": {
      "$ref": "#/$defs/CostingKind",
      "default": "auto",
      "description": "Costing model for the route and detour matrix: \"auto\" (default),\n\"truck\", \"bicycle\", \"pedestrian\" or \"motor_scooter\"."
    },
    "destination": {
      "anyOf": [
        {
          "$ref": "#/$defs/LatLon"
        },
        {
          "type": "null"
        }
      ],
      "description": "Route destination."
    },
    "fill_litres": {
      "type": [
        "number",
        "null"
      ],
      "format": "double",
      "description": "Optional fill size in litres; each result then also carries\n`saving_total` = `saving_per_litre` × `fill_litres`."
    },
    "max_results": {
      "type": [
        "integer",
        "null"
      ],
      "format": "uint32",
      "minimum": 0,
      "description": "Maximum results (default 5, at most 25)."
    },
    "geometry_polyline6": {
      "type": [
        "string",
        "null"
      ],
      "description": "An existing route geometry as an encoded polyline6 (the `route`\ntool's `geometry_polyline6`). Provide either this or `origin` +\n`destination`, not both."
    },
    "max_detour_minutes": {
      "type": [
        "number",
        "null"
      ],
      "format": "double",
      "description": "Largest acceptable detour in minutes (default 10, at most 120)."
    }
  }
}

{
  "type": "object",
  "$defs": {
    "LatLon": {
      "anyOf": [
        {
          "type": "object",
          "required": [
            "lat",
            "lon"
          ],
          "properties": {
            "lat": {
              "type": "number",
              "format": "double",
              "description": "Latitude in decimal degrees (−90 to 90)."
            },
            "lon": {
              "type": "number",
              "format": "double",
              "description": "Longitude in decimal degrees (−180 to 180)."
            }
          }
        },
        {
          "type": "array",
          "items": {
            "type": "number",
            "format": "double"
          },
          "maxItems": 2,
          "minItems": 2,
          "description": "GeoJSON position [lon, lat]: longitude FIRST."
        }
      ],
      "description": "A WGS84 coordinate in decimal degrees: a {lat, lon} object (preferred), or a GeoJSON [lon, lat] array with LONGITUDE FIRST, the same order as every polygon field on this server."
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "origin",
    "destination",
    "height_m"
  ],
  "properties": {
    "origin": {
      "$ref": "#/$defs/LatLon",
      "description": "Route origin."
    },
    "width_m": {
      "type": [
        "number",
        "null"
      ],
      "format": "double",
      "description": "Vehicle width in metres. Supplying it asks the width axis as well as\nthe height axis; the width answer is reported separately and is\nnever a headroom."
    },
    "height_m": {
      "type": "number",
      "format": "double",
      "description": "Vehicle height in metres. Required: there is no default vehicle,\nbecause a default vehicle is how somebody gets an answer about a\nlorry that is not theirs."
    },
    "margin_m": {
      "type": [
        "number",
        "null"
      ],
      "format": "double",
      "description": "Operating margin in metres, added to the height before the verdict\nis decided (default 0). Your compliance policy, not ours: the\nmeasured figure and the safe bound are both reported whatever you\nset here, and the margin is echoed back. It is applied to the\nmeasurement, not to the routing step, where the map's own posted\nheights already carry a margin of their own."
    },
    "destination": {
      "$ref": "#/$defs/LatLon",
      "description": "Route destination."
    }
  }
}

{
  "type": "object",
  "$defs": {
    "TerritorySpec": {
      "type": "object",
      "required": [
        "id",
        "polygon"
      ],
      "properties": {
        "id": {
          "type": "string",
          "description": "Caller-chosen id, echoed back and referenced by\n`vehicles[].territory_ids`. Must be unique within the request."
        },
        "polygon": {
          "type": "array",
          "items": {
            "type": "array",
            "items": {
              "type": "number",
              "format": "double"
            },
            "maxItems": 2,
            "minItems": 2
          },
          "description": "The outer ring as GeoJSON `[lon, lat]` positions, longitude\nFIRST. Closed or open; an unclosed ring is closed for you."
        }
      },
      "description": "One named territory: a polygon that bounds which vehicle may serve\nwhich stop."
    },
    "ClusterLocationSpec": {
      "type": "object",
      "required": [
        "id",
        "lat",
        "lon"
      ],
      "properties": {
        "id": {
          "type": "string",
          "description": "Caller-chosen id, echoed back as the cluster's membership. Must be\nunique within the request."
        },
        "lat": {
          "type": "number",
          "format": "double",
          "description": "Latitude in decimal degrees."
        },
        "lon": {
          "type": "number",
          "format": "double",
          "description": "Longitude in decimal degrees."
        },
        "load": {
          "type": [
            "number",
            "null"
          ],
          "format": "double",
          "description": "Optional weight, parcels, kilograms, litres, minutes of service.\nSummed per cluster and reported; constrains the clustering only\nunder `max_cluster_load`."
        }
      },
      "description": "One stop to be clustered."
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "locations"
  ],
  "properties": {
    "seed": {
      "type": [
        "integer",
        "null"
      ],
      "format": "uint64",
      "minimum": 0,
      "description": "Seed for the k-means++ seeding (default 42). The same request with\nthe same seed always returns the same clusters, on every\ndeployment."
    },
    "clusters": {
      "type": [
        "integer",
        "null"
      ],
      "format": "uint32",
      "minimum": 0,
      "description": "How many clusters to produce, balanced by stop count. Give exactly\none of `clusters`, `max_cluster_locations` or `max_cluster_load`."
    },
    "locations": {
      "type": "array",
      "items": {
        "$ref": "#/$defs/ClusterLocationSpec"
      },
      "description": "The stops to group. Ids must be unique; at most 5,000."
    },
    "territories": {
      "type": [
        "array",
        "null"
      ],
      "items": {
        "$ref": "#/$defs/TerritorySpec"
      },
      "description": "Optional territories. Given, no cluster straddles one: each\nterritory is clustered on its own, and so are the stops inside none\nof them."
    },
    "max_cluster_load": {
      "type": [
        "number",
        "null"
      ],
      "format": "double",
      "description": "At most this much summed `load` per cluster; the cluster count is\nderived from it. A load ceiling with lumpy loads is a bin-packing\nproblem and may have no solution at the derived count, the\nresponse says so rather than pretending."
    },
    "max_cluster_locations": {
      "type": [
        "integer",
        "null"
      ],
      "format": "uint32",
      "minimum": 0,
      "description": "At most this many stops per cluster; the cluster count is derived\nfrom it."
    }
  }
}

{
  "type": "object",
  "$defs": {
    "LatLon": {
      "anyOf": [
        {
          "type": "object",
          "required": [
            "lat",
            "lon"
          ],
          "properties": {
            "lat": {
              "type": "number",
              "format": "double",
              "description": "Latitude in decimal degrees (−90 to 90)."
            },
            "lon": {
              "type": "number",
              "format": "double",
              "description": "Longitude in decimal degrees (−180 to 180)."
            }
          }
        },
        {
          "type": "array",
          "items": {
            "type": "number",
            "format": "double"
          },
          "maxItems": 2,
          "minItems": 2,
          "description": "GeoJSON position [lon, lat]: longitude FIRST."
        }
      ],
      "description": "A WGS84 coordinate in decimal degrees: a {lat, lon} object (preferred), or a GeoJSON [lon, lat] array with LONGITUDE FIRST, the same order as every polygon field on this server."
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "city": {
      "type": [
        "string",
        "null"
      ],
      "description": "Structured component: town or city, e.g. \"London\". Matches the\ncontaining city as well as the immediate locality, so a suburb name\nworks here too."
    },
    "lang": {
      "type": [
        "string",
        "null"
      ],
      "description": "Language of the place names to match and return, as a two-letter\ncode. Defaults to \"en\", which is what makes English exonyms\n(\"Munich\", \"Cologne\", \"Geneva\") resolve to the place meant rather\nthan a same-named town elsewhere. Set it to the language your\nquery is written in; \"default\" asks for each place's own local\nname. Deployments support a fixed set (this one: \"en\", \"de\",\n\"fr\"), and anything outside it is refused."
    },
    "focus": {
      "anyOf": [
        {
          "$ref": "#/$defs/LatLon"
        },
        {
          "type": "null"
        }
      ],
      "description": "Optional location bias: results near this point rank higher."
    },
    "limit": {
      "type": [
        "integer",
        "null"
      ],
      "format": "uint32",
      "minimum": 0,
      "description": "Maximum number of results (1–50, default 10)."
    },
    "query": {
      "type": [
        "string",
        "null"
      ],
      "description": "Free-text place query, e.g. \"Dover ferry terminal\". Required unless\nat least one structured component is supplied."
    },
    "street": {
      "type": [
        "string",
        "null"
      ],
      "description": "Structured component: street name, e.g. \"Downing Street\". Matches\nthe street of addresses and POIs (transliterated street names\nincluded) as well as the street itself."
    },
    "country": {
      "type": [
        "string",
        "null"
      ],
      "description": "Structured component: ISO 3166-1 alpha-2 code or country name,\n\"GB\", \"gb\", \"United Kingdom\" and \"UK\" all mean the same country.\nA value naming no country is refused rather than quietly applied as\na filter that matches nothing."
    },
    "postcode": {
      "type": [
        "string",
        "null"
      ],
      "description": "Structured component: postcode in any spacing or case, \"SW1A 2AA\"\nand \"sw1a2aa\" are one query. A bare UK outward code (\"SW1A\")\nselects the whole district."
    },
    "housenumber": {
      "type": [
        "string",
        "null"
      ],
      "description": "Structured component: house number, e.g. \"10\" or \"221B\". Only\nmeaningful alongside `street`, a house number on its own excludes\nnearly everything and identifies nothing."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "geometry_polyline6"
  ],
  "properties": {
    "max_lines": {
      "type": [
        "integer",
        "null"
      ],
      "format": "uint32",
      "minimum": 0,
      "description": "Ceiling on how many lines come back, 1 to 50 (default 12)."
    },
    "min_gap_m": {
      "type": [
        "number",
        "null"
      ],
      "format": "double",
      "description": "Least distance between two lines, metres (default 400). A floor\nunder the time budget in every case."
    },
    "min_gap_s": {
      "type": [
        "number",
        "null"
      ],
      "format": "double",
      "description": "Least time between two lines, seconds (default 900, which is four\nan hour). Applied only with `duration_s`."
    },
    "duration_s": {
      "type": [
        "number",
        "null"
      ],
      "format": "double",
      "description": "That route's own duration, seconds: `duration_s` from the same\nanswer. **Supply it.** Without it the silence budget falls back to\na distance, and \"three to five lines an hour\" is a claim about\ntime that a distance answers wrongly at both ends."
    },
    "max_offset_m": {
      "type": [
        "number",
        "null"
      ],
      "format": "double",
      "description": "How near a plaque must come to the route before its line may be\nspoken, metres (default 60, hard ceiling 80)."
    },
    "voice_format": {
      "type": [
        "string",
        "null"
      ],
      "description": "Container to address each line's audio clip in: `opus` or `m4a`.\nGiven, every line gains a `clip` with its synthesis cache key and\nURL. It NEVER synthesises: the key is a pure function of the\nsentence, so asking here buys nothing."
    },
    "geometry_polyline6": {
      "type": "string",
      "description": "The route shape, precision-6 encoded: `geometry_polyline6`\nstraight out of the `route` tool's answer."
    }
  }
}

{
  "type": "object",
  "$defs": {
    "LatLon": {
      "anyOf": [
        {
          "type": "object",
          "required": [
            "lat",
            "lon"
          ],
          "properties": {
            "lat": {
              "type": "number",
              "format": "double",
              "description": "Latitude in decimal degrees (−90 to 90)."
            },
            "lon": {
              "type": "number",
              "format": "double",
              "description": "Longitude in decimal degrees (−180 to 180)."
            }
          }
        },
        {
          "type": "array",
          "items": {
            "type": "number",
            "format": "double"
          },
          "maxItems": 2,
          "minItems": 2,
          "description": "GeoJSON position [lon, lat]: longitude FIRST."
        }
      ],
      "description": "A WGS84 coordinate in decimal degrees: a {lat, lon} object (preferred), or a GeoJSON [lon, lat] array with LONGITUDE FIRST, the same order as every polygon field on this server."
    },
    "CostingKind": {
      "oneOf": [
        {
          "type": "string",
          "const": "auto",
          "description": "Standard car costing."
        },
        {
          "type": "string",
          "const": "truck",
          "description": "Truck costing; honours dimensional limits and, when a `truck`\nprofile is supplied, ADR dangerous-goods restrictions."
        },
        {
          "type": "string",
          "const": "bicycle",
          "description": "Bicycle costing; tune it with a `bicycle` options object."
        },
        {
          "type": "string",
          "const": "pedestrian",
          "description": "Pedestrian (walking) costing; tune it with a `pedestrian` options\nobject (lit streets, wheelchair/blind, hiking difficulty)."
        },
        {
          "type": "string",
          "const": "motor_scooter",
          "description": "Motor scooter (moped) costing: like auto but prefers lower-speed\nroads and may use ways closed to larger motor vehicles."
        }
      ],
      "description": "Costing models exposed by the MCP tools (a deliberate subset of the\nValhalla costing list), serialised in snake_case exactly as Valhalla\nnames them."
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "shape": {
      "type": [
        "array",
        "null"
      ],
      "items": {
        "$ref": "#/$defs/LatLon"
      },
      "description": "The trace as an ordered list of recorded points, oldest first.\nBetween 2 and 2000 points. Provide this or `encoded_polyline`."
    },
    "costing": {
      "anyOf": [
        {
          "$ref": "#/$defs/CostingKind"
        },
        {
          "type": "null"
        }
      ],
      "description": "Costing model the trace was travelled under: `auto` (default),\n`truck`, `bicycle`, `pedestrian` or `motor_scooter`. It decides\nwhich roads the trace may be matched onto, so a walked trace\nmatched as `auto` snaps to the carriageway rather than the path."
    },
    "encoded_polyline": {
      "type": [
        "string",
        "null"
      ],
      "description": "The trace as a Google encoded polyline with six digits of decimal\nprecision (polyline6), the geometry `route` and `match_trace`\nthemselves return. Provide this or `shape`."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "lat",
    "lon"
  ],
  "properties": {
    "lat": {
      "type": "number",
      "format": "double",
      "description": "Latitude of the search point in decimal degrees (−90 to 90)."
    },
    "lon": {
      "type": "number",
      "format": "double",
      "description": "Longitude of the search point in decimal degrees (−180 to 180)."
    },
    "name": {
      "type": [
        "string",
        "null"
      ],
      "description": "The name or brand of the place to find, \"Lloyds\", \"Lloyds Bank\",\n\"Sainsbury's\", for \"where is the nearest X\" questions. Every word\nmust appear in the place's name or one of its alternative names,\ncase- and accent-insensitively, with the last word also matching as\na prefix (\"Sains\" finds Sainsbury's). Combine with `category` to\ndisambiguate a brand used by more than one kind of place (\"Lloyds\"\nplus \"bank\" excludes Lloyds Pharmacy). Optional when `category` is\ngiven; at least one of the two is required."
    },
    "limit": {
      "type": [
        "integer",
        "null"
      ],
      "format": "uint32",
      "minimum": 0,
      "description": "Maximum number of results (1–10, default 5)."
    },
    "fov_deg": {
      "type": [
        "number",
        "null"
      ],
      "format": "double",
      "description": "Field of view: the full width in degrees of a cone centred on\n`heading_deg`, outside which results are dropped, it is the\nFULL width, so 90 keeps only what lies within 45 degrees either\nside of dead ahead. Needs\n`heading_deg`, a cone has to point somewhere. The count of\nresults removed is reported as `out_of_view`."
    },
    "category": {
      "type": [
        "string",
        "null"
      ],
      "description": "The kind of place to find. The gateway matches it against the\nindex's lowercased OSM tag values (the value of the POI's\n`amenity`/`shop`/`tourism`/`railway`/… tag), e.g. \"cafe\", \"fuel\",\n\"charging_station\", \"parking\", \"pharmacy\", \"supermarket\", \"hotel\",\n\"restaurant\", \"fast_food\", \"atm\", \"bakery\", \"hospital\", \"station\",\nand normalises common colloquial names first (\"coffee\" → cafe;\n\"ev_charging\", \"ev charging\" → charging_station; \"petrol\" → fuel;\n\"chemist\" → pharmacy). A category the index does not carry matches\nnothing: the result is an empty list, not an error. Optional when\n`name` is given; at least one of the two is required."
    },
    "radius_m": {
      "type": [
        "integer",
        "null"
      ],
      "format": "uint32",
      "minimum": 0,
      "description": "Maximum straight-line distance of any result from the point, in\nmetres (1–100000, default 2500)."
    },
    "heading_deg": {
      "type": [
        "number",
        "null"
      ],
      "format": "double",
      "description": "Which way the user is facing, in degrees **clockwise from true\nnorth** (0 = north, 90 = east, 180 = south, 270 = west). Supply it\nand every result is also described from the user's point of view\n(\"just ahead on your right\"); omit it and results fall back to\ncardinal directions (\"to the north-east\"), so the tool works with\nor without a compass."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "lat",
    "lon",
    "bearing_deg"
  ],
  "properties": {
    "lat": {
      "type": "number",
      "format": "double",
      "description": "Latitude of the observer in decimal degrees (−90 to 90)."
    },
    "lon": {
      "type": "number",
      "format": "double",
      "description": "Longitude of the observer in decimal degrees (−180 to 180)."
    },
    "name": {
      "type": [
        "string",
        "null"
      ],
      "description": "A place name or brand to look for. At least one of `category` and\n`name` is required."
    },
    "limit": {
      "type": [
        "integer",
        "null"
      ],
      "format": "uint32",
      "minimum": 0,
      "description": "Maximum number of results (1–25, default 5)."
    },
    "fov_deg": {
      "type": [
        "number",
        "null"
      ],
      "format": "double",
      "description": "Full width in degrees of the cone centred on `bearing_deg` (1–360,\ndefault 60, so 30 degrees either side). The FULL width, not the\nhalf angle."
    },
    "category": {
      "type": [
        "string",
        "null"
      ],
      "description": "The kind of place to look for, from the same vocabulary\n`nearby_places` uses (\"cafe\", \"pub\", \"fuel\", \"charging_station\" …).\nUse \"building\" to ask what a named building over there is. At\nleast one of `category` and `name` is required."
    },
    "radius_m": {
      "type": [
        "integer",
        "null"
      ],
      "format": "uint32",
      "minimum": 0,
      "description": "Maximum straight-line range in metres (1–5000, default 1000)."
    },
    "bearing_deg": {
      "type": "number",
      "format": "double",
      "description": "Which way the observer is facing, in degrees **clockwise from true\nnorth** (0 = north, 90 = east, 180 = south, 270 = west). Required:\nthis tool answers \"what is over there\", and \"there\" has to point\nsomewhere."
    },
    "eye_height_m": {
      "type": [
        "number",
        "null"
      ],
      "format": "double",
      "description": "Height of the observer's eye above the ground in metres (0–500,\ndefault 1.6, a standing adult). A driver's eye is nearer 1.2 m."
    },
    "visible_only": {
      "type": [
        "boolean",
        "null"
      ],
      "description": "When true, return only places whose visibility verdict is `clear`.\nDefault false, which returns everything in the cone WITH its\nverdict, usually the better answer, because \"it is there but you\ncannot see it from here\" is worth saying."
    }
  }
}

{
  "type": "object",
  "$defs": {
    "LatLon": {
      "anyOf": [
        {
          "type": "object",
          "required": [
            "lat",
            "lon"
          ],
          "properties": {
            "lat": {
              "type": "number",
              "format": "double",
              "description": "Latitude in decimal degrees (−90 to 90)."
            },
            "lon": {
              "type": "number",
              "format": "double",
              "description": "Longitude in decimal degrees (−180 to 180)."
            }
          }
        },
        {
          "type": "array",
          "items": {
            "type": "number",
            "format": "double"
          },
          "maxItems": 2,
          "minItems": 2,
          "description": "GeoJSON position [lon, lat]: longitude FIRST."
        }
      ],
      "description": "A WGS84 coordinate in decimal degrees: a {lat, lon} object (preferred), or a GeoJSON [lon, lat] array with LONGITUDE FIRST, the same order as every polygon field on this server."
    },
    "TruckSpec": {
      "type": "object",
      "properties": {
        "hazmat": {
          "type": "boolean",
          "default": false,
          "description": "Whether the vehicle carries dangerous goods (ADR). Defaults to\nfalse."
        },
        "width_m": {
          "type": [
            "number",
            "null"
          ],
          "format": "double",
          "description": "Vehicle width in metres."
        },
        "height_m": {
          "type": [
            "number",
            "null"
          ],
          "format": "double",
          "description": "Vehicle height in metres."
        },
        "length_m": {
          "type": [
            "number",
            "null"
          ],
          "format": "double",
          "description": "Vehicle length in metres."
        },
        "tunnel_code": {
          "type": [
            "string",
            "null"
          ],
          "description": "ADR 8.6.4 tunnel restriction code of the load, e.g. \"B\", \"C5000D\",\n\"B/D\", or \"(-)\"/\"none\" for explicitly unrestricted. Leave unset if\nunknown: a hazmat load without a code is conservatively treated as\ncode B (allowed only through category-A tunnels)."
        },
        "gross_weight_t": {
          "type": [
            "number",
            "null"
          ],
          "format": "double",
          "description": "Gross combination weight in metric tonnes."
        }
      },
      "description": "Truck profile for routing: physical dimensions plus the ADR\ndangerous-goods declaration. Omitted dimensions default to the EU\nmaximum authorised dimensions of Council Directive 96/53/EC (4.0 m\nheight, 2.55 m width, 16.5 m length, 40 t gross weight)."
    },
    "CostingKind": {
      "oneOf": [
        {
          "type": "string",
          "const": "auto",
          "description": "Standard car costing."
        },
        {
          "type": "string",
          "const": "truck",
          "description": "Truck costing; honours dimensional limits and, when a `truck`\nprofile is supplied, ADR dangerous-goods restrictions."
        },
        {
          "type": "string",
          "const": "bicycle",
          "description": "Bicycle costing; tune it with a `bicycle` options object."
        },
        {
          "type": "string",
          "const": "pedestrian",
          "description": "Pedestrian (walking) costing; tune it with a `pedestrian` options\nobject (lit streets, wheelchair/blind, hiking difficulty)."
        },
        {
          "type": "string",
          "const": "motor_scooter",
          "description": "Motor scooter (moped) costing: like auto but prefers lower-speed\nroads and may use ways closed to larger motor vehicles."
        }
      ],
      "description": "Costing models exposed by the MCP tools (a deliberate subset of the\nValhalla costing list), serialised in snake_case exactly as Valhalla\nnames them."
    },
    "PlanDayStopInput": {
      "type": "object",
      "properties": {
        "name": {
          "type": [
            "string",
            "null"
          ],
          "description": "Free-text name or address, geocoded when no `location` is given."
        },
        "location": {
          "anyOf": [
            {
              "$ref": "#/$defs/LatLon"
            },
            {
              "type": "null"
            }
          ],
          "description": "Exact coordinates; skips geocoding."
        },
        "dwell_minutes": {
          "type": [
            "number",
            "null"
          ],
          "format": "double",
          "description": "Time spent at the stop in minutes (default 0); shifts every later\nETA."
        }
      },
      "description": "One stop of a `plan_day` itinerary: an exact location, or a free-text\nname to geocode (ambiguous matches are flagged in the response, never\nguessed silently)."
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "start",
    "stops"
  ],
  "properties": {
    "start": {
      "$ref": "#/$defs/PlanDayStopInput",
      "description": "Where the day starts (name or location; `dwell_minutes` ignored)."
    },
    "stops": {
      "type": "array",
      "items": {
        "$ref": "#/$defs/PlanDayStopInput"
      },
      "description": "The stops to visit (1–20). Visited in the given order unless\n`optimise` is true."
    },
    "truck": {
      "anyOf": [
        {
          "$ref": "#/$defs/TruckSpec"
        },
        {
          "type": "null"
        }
      ],
      "description": "Truck profile (dimensions + ADR declaration). Requires costing\n\"truck\"."
    },
    "costing": {
      "$ref": "#/$defs/CostingKind",
      "default": "auto",
      "description": "Costing model: \"auto\" (default), \"truck\", \"bicycle\", \"pedestrian\"\nor \"motor_scooter\"."
    },
    "optimise": {
      "type": "boolean",
      "default": false,
      "description": "Reorder the stops for the shortest day (VROOM solver; requires the\noptimisation sidecar). Default false: visit in the given order."
    },
    "depart_at": {
      "type": [
        "string",
        "null"
      ],
      "description": "Departure time as RFC 3339 (e.g. \"2026-07-18T09:00:00Z\"); when\ngiven, every ETA is also returned as an absolute timestamp."
    },
    "return_to_start": {
      "type": "boolean",
      "default": false,
      "description": "End the day back at the start (default false)."
    }
  }
}

{
  "type": "object",
  "$defs": {
    "LatLon": {
      "anyOf": [
        {
          "type": "object",
          "required": [
            "lat",
            "lon"
          ],
          "properties": {
            "lat": {
              "type": "number",
              "format": "double",
              "description": "Latitude in decimal degrees (−90 to 90)."
            },
            "lon": {
              "type": "number",
              "format": "double",
              "description": "Longitude in decimal degrees (−180 to 180)."
            }
          }
        },
        {
          "type": "array",
          "items": {
            "type": "number",
            "format": "double"
          },
          "maxItems": 2,
          "minItems": 2,
          "description": "GeoJSON position [lon, lat]: longitude FIRST."
        }
      ],
      "description": "A WGS84 coordinate in decimal degrees: a {lat, lon} object (preferred), or a GeoJSON [lon, lat] array with LONGITUDE FIRST, the same order as every polygon field on this server."
    },
    "ErrandSpec": {
      "type": "object",
      "properties": {
        "id": {
          "type": [
            "string",
            "null"
          ],
          "description": "What to call this errand in the answer (\"prescription\", \"petrol\").\nDefaults to the category, or to \"stop N\"."
        },
        "place": {
          "anyOf": [
            {
              "$ref": "#/$defs/LatLon"
            },
            {
              "type": "null"
            }
          ],
          "description": "A specific place the driver already knows, as a coordinate. Use\nthis for \"the school\", \"the nursery\", \"Mum's\": places the map\ncannot be expected to resolve from the words alone. Resolve a NAMED\nplace with `geocode` first and pass the coordinate here; never\nguess one."
        },
        "category": {
          "type": [
            "string",
            "null"
          ],
          "description": "The KIND of place wanted: a category from `list_place_categories`\n(\"pharmacy\", \"fuel\", \"supermarket\"), or a colloquial phrase the\nserver normalises (\"petrol station\", \"chemist\"). Use this for\nanything the driver described by what it is rather than by name."
        },
        "dwell_minutes": {
          "type": [
            "number",
            "null"
          ],
          "format": "double",
          "description": "How long the driver is out of the car here, minutes (default 5)."
        }
      },
      "description": "One errand in a `plan_errands` chain: a kind of place to find, or a\nplace the caller already knows."
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "origin",
    "destination",
    "arrive_by",
    "errands"
  ],
  "properties": {
    "origin": {
      "$ref": "#/$defs/LatLon",
      "description": "Where the driver sets off from."
    },
    "errands": {
      "type": "array",
      "items": {
        "$ref": "#/$defs/ErrandSpec"
      },
      "description": "The errands, in any order: the answer decides the order. One to\nfive."
    },
    "arrive_by": {
      "type": "string",
      "description": "The hard arrival time, RFC 3339 with an offset\n(\"2026-09-21T15:15:00+01:00\"). Convert \"quarter past three\" to an\nabsolute instant in the driver's own offset before calling."
    },
    "depart_at": {
      "type": [
        "string",
        "null"
      ],
      "description": "When they set off, RFC 3339. Defaults to now."
    },
    "destination": {
      "$ref": "#/$defs/LatLon",
      "description": "Where they have to be by `arrive_by`."
    },
    "destination_name": {
      "type": [
        "string",
        "null"
      ],
      "description": "What to call the destination in the answer (\"the school\")."
    },
    "max_detour_minutes": {
      "type": [
        "number",
        "null"
      ],
      "format": "double",
      "description": "How far off the direct route a candidate place may sit, as a detour\nin minutes (default 12, at most 45)."
    }
  }
}

{
  "type": "object",
  "$defs": {
    "LatLon": {
      "anyOf": [
        {
          "type": "object",
          "required": [
            "lat",
            "lon"
          ],
          "properties": {
            "lat": {
              "type": "number",
              "format": "double",
              "description": "Latitude in decimal degrees (−90 to 90)."
            },
            "lon": {
              "type": "number",
              "format": "double",
              "description": "Longitude in decimal degrees (−180 to 180)."
            }
          }
        },
        {
          "type": "array",
          "items": {
            "type": "number",
            "format": "double"
          },
          "maxItems": 2,
          "minItems": 2,
          "description": "GeoJSON position [lon, lat]: longitude FIRST."
        }
      ],
      "description": "A WGS84 coordinate in decimal degrees: a {lat, lon} object (preferred), or a GeoJSON [lon, lat] array with LONGITUDE FIRST, the same order as every polygon field on this server."
    },
    "EvVehicleSpec": {
      "type": "object",
      "properties": {
        "name": {
          "type": [
            "string",
            "null"
          ],
          "description": "Display name for the vehicle in the answer."
        },
        "aux_kw": {
          "type": [
            "number",
            "null"
          ],
          "format": "double",
          "description": "Auxiliary load in kW, lights, electronics, cabin conditioning.\nWinter heating is several times the mild-weather default."
        },
        "mass_kg": {
          "type": [
            "number",
            "null"
          ],
          "format": "double",
          "description": "Kerb mass, kg."
        },
        "profile": {
          "type": [
            "string",
            "null"
          ],
          "description": "A published default profile: \"small_hatch\", \"saloon\", \"suv\" or\n\"van\". On its own it selects that vehicle; alongside any inline\nfigure below it is the base the figure overrides."
        },
        "connectors": {
          "type": [
            "array",
            "null"
          ],
          "items": {
            "type": "string"
          },
          "description": "Connectors the vehicle accepts: \"type1\", \"type2\", \"ccs1\", \"ccs2\",\n\"chademo\", \"tesla\", \"gbt\"."
        },
        "battery_kwh": {
          "type": [
            "number",
            "null"
          ],
          "format": "double",
          "description": "Gross nominal battery capacity, kWh."
        },
        "drag_area_m2": {
          "type": [
            "number",
            "null"
          ],
          "format": "double",
          "description": "Drag area (drag coefficient × frontal area), m²."
        },
        "usable_fraction": {
          "type": [
            "number",
            "null"
          ],
          "format": "double",
          "description": "Fraction of the gross pack the vehicle will actually use, 0–1."
        }
      },
      "description": "The vehicle for `plan_ev_route`: one of the published defaults by name,\ninline figures, or a named default with inline figures over it."
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "origin",
    "destination"
  ],
  "properties": {
    "min_kw": {
      "type": [
        "number",
        "null"
      ],
      "format": "double",
      "description": "Keep only charge points with a usable connector rated at least this\nmany kW (e.g. 50 for rapid charging only)."
    },
    "origin": {
      "$ref": "#/$defs/LatLon",
      "description": "Where the journey starts."
    },
    "vehicle": {
      "anyOf": [
        {
          "$ref": "#/$defs/EvVehicleSpec"
        },
        {
          "type": "null"
        }
      ],
      "description": "The vehicle. Omitted ⇒ the published \"saloon\" default, and the\nanswer says which vehicle it used."
    },
    "start_soc": {
      "type": [
        "number",
        "null"
      ],
      "format": "double",
      "description": "State of charge at the start, 0–1 (default 0.9)."
    },
    "waypoints": {
      "type": [
        "array",
        "null"
      ],
      "items": {
        "$ref": "#/$defs/LatLon"
      },
      "description": "Intermediate points the route must pass through, in order (at most\n8). Charge stops are inserted around them."
    },
    "connectors": {
      "type": [
        "array",
        "null"
      ],
      "items": {
        "type": "string"
      },
      "description": "Keep only charge points offering at least one of these connector\nstandards: \"type2\", \"type1\", \"ccs\", \"chademo\", \"tesla\", \"domestic\",\n\"other\". This narrows the vehicle's own set, never widens it."
    },
    "destination": {
      "$ref": "#/$defs/LatLon",
      "description": "Where it ends."
    },
    "reserve_soc": {
      "type": [
        "number",
        "null"
      ],
      "format": "double",
      "description": "The floor the state of charge must never fall below mid-route\n(default 0.1). Distinct from the arrival figure."
    },
    "min_arrival_soc": {
      "type": [
        "number",
        "null"
      ],
      "format": "double",
      "description": "Lowest acceptable state of charge on arrival (default 0.1)."
    },
    "max_detour_minutes": {
      "type": [
        "number",
        "null"
      ],
      "format": "double",
      "description": "How far off the route a charge point may sit, as a detour in\nminutes (default 15, at most 120)."
    },
    "ambient_temperature_c": {
      "type": [
        "number",
        "null"
      ],
      "format": "double",
      "description": "Ambient temperature in °C. Derates traction energy from a published\nstudy; cabin heating belongs in the vehicle's `aux_kw`."
    }
  }
}

{
  "type": "object",
  "$defs": {
    "LatLon": {
      "anyOf": [
        {
          "type": "object",
          "required": [
            "lat",
            "lon"
          ],
          "properties": {
            "lat": {
              "type": "number",
              "format": "double",
              "description": "Latitude in decimal degrees (−90 to 90)."
            },
            "lon": {
              "type": "number",
              "format": "double",
              "description": "Longitude in decimal degrees (−180 to 180)."
            }
          }
        },
        {
          "type": "array",
          "items": {
            "type": "number",
            "format": "double"
          },
          "maxItems": 2,
          "minItems": 2,
          "description": "GeoJSON position [lon, lat]: longitude FIRST."
        }
      ],
      "description": "A WGS84 coordinate in decimal degrees: a {lat, lon} object (preferred), or a GeoJSON [lon, lat] array with LONGITUDE FIRST, the same order as every polygon field on this server."
    },
    "CostingKind": {
      "oneOf": [
        {
          "type": "string",
          "const": "auto",
          "description": "Standard car costing."
        },
        {
          "type": "string",
          "const": "truck",
          "description": "Truck costing; honours dimensional limits and, when a `truck`\nprofile is supplied, ADR dangerous-goods restrictions."
        },
        {
          "type": "string",
          "const": "bicycle",
          "description": "Bicycle costing; tune it with a `bicycle` options object."
        },
        {
          "type": "string",
          "const": "pedestrian",
          "description": "Pedestrian (walking) costing; tune it with a `pedestrian` options\nobject (lit streets, wheelchair/blind, hiking difficulty)."
        },
        {
          "type": "string",
          "const": "motor_scooter",
          "description": "Motor scooter (moped) costing: like auto but prefers lower-speed\nroads and may use ways closed to larger motor vehicles."
        }
      ],
      "description": "Costing models exposed by the MCP tools (a deliberate subset of the\nValhalla costing list), serialised in snake_case exactly as Valhalla\nnames them."
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "origin",
    "contours_minutes"
  ],
  "properties": {
    "origin": {
      "$ref": "#/$defs/LatLon",
      "description": "Origin the reachable area is computed from."
    },
    "costing": {
      "$ref": "#/$defs/CostingKind",
      "default": "auto",
      "description": "Travel mode: \"auto\" (default), \"truck\", \"bicycle\", \"pedestrian\"\nor \"motor_scooter\"."
    },
    "polygons": {
      "type": [
        "boolean",
        "null"
      ],
      "description": "Return filled polygons instead of contour linestrings (default\nfalse). Polygons draw directly as a MapLibre fill layer."
    },
    "contours_minutes": {
      "type": "array",
      "items": {
        "type": "number",
        "format": "double"
      },
      "description": "Contour boundaries in minutes of travel time, e.g. [5, 10, 15]\nfor 5/10/15-minute rings. 1 to 4 values (the routing engine's\nlimit), each between 0 and 120 minutes."
    },
    "exclude_polygons": {
      "type": [
        "array",
        "null"
      ],
      "items": {
        "type": "array",
        "items": {
          "type": "array",
          "items": {
            "type": "number",
            "format": "double"
          },
          "maxItems": 2,
          "minItems": 2
        }
      },
      "description": "Areas to avoid, scenario analysis (\"close this bridge and\nrecompute reachability\"): an array of polygons, each an array of\n`[lon, lat]` pairs forming one exterior ring (GeoJSON-style,\nlongitude FIRST). Roads intersecting any ring are excluded from\nthe reachability search. Applies to the Valhalla engine;\nunsupported on the GraphHopper engine, where it is ignored."
    }
  }
}

{
  "type": "object",
  "$defs": {
    "LatLon": {
      "anyOf": [
        {
          "type": "object",
          "required": [
            "lat",
            "lon"
          ],
          "properties": {
            "lat": {
              "type": "number",
              "format": "double",
              "description": "Latitude in decimal degrees (−90 to 90)."
            },
            "lon": {
              "type": "number",
              "format": "double",
              "description": "Longitude in decimal degrees (−180 to 180)."
            }
          }
        },
        {
          "type": "array",
          "items": {
            "type": "number",
            "format": "double"
          },
          "maxItems": 2,
          "minItems": 2,
          "description": "GeoJSON position [lon, lat]: longitude FIRST."
        }
      ],
      "description": "A WGS84 coordinate in decimal degrees: a {lat, lon} object (preferred), or a GeoJSON [lon, lat] array with LONGITUDE FIRST, the same order as every polygon field on this server."
    },
    "RelaxSpec": {
      "type": "object",
      "properties": {
        "allow_overtime_s": {
          "type": [
            "integer",
            "null"
          ],
          "format": "int64",
          "description": "Extend every vehicle's shift END by this many seconds. Shift starts\nare never moved earlier, a driver cannot begin before they begin."
        },
        "time_windows_by_s": {
          "type": [
            "integer",
            "null"
          ],
          "format": "int64",
          "description": "Widen every task time window by this many seconds at EACH end. A\n09:00–12:00 window with 1800 becomes 08:30–12:30."
        }
      },
      "description": "What the caller is willing to give up if the first solve leaves work\nunassigned. At least one field is required."
    },
    "TruckSpec": {
      "type": "object",
      "properties": {
        "hazmat": {
          "type": "boolean",
          "default": false,
          "description": "Whether the vehicle carries dangerous goods (ADR). Defaults to\nfalse."
        },
        "width_m": {
          "type": [
            "number",
            "null"
          ],
          "format": "double",
          "description": "Vehicle width in metres."
        },
        "height_m": {
          "type": [
            "number",
            "null"
          ],
          "format": "double",
          "description": "Vehicle height in metres."
        },
        "length_m": {
          "type": [
            "number",
            "null"
          ],
          "format": "double",
          "description": "Vehicle length in metres."
        },
        "tunnel_code": {
          "type": [
            "string",
            "null"
          ],
          "description": "ADR 8.6.4 tunnel restriction code of the load, e.g. \"B\", \"C5000D\",\n\"B/D\", or \"(-)\"/\"none\" for explicitly unrestricted. Leave unset if\nunknown: a hazmat load without a code is conservatively treated as\ncode B (allowed only through category-A tunnels)."
        },
        "gross_weight_t": {
          "type": [
            "number",
            "null"
          ],
          "format": "double",
          "description": "Gross combination weight in metric tonnes."
        }
      },
      "description": "Truck profile for routing: physical dimensions plus the ADR\ndangerous-goods declaration. Omitted dimensions default to the EU\nmaximum authorised dimensions of Council Directive 96/53/EC (4.0 m\nheight, 2.55 m width, 16.5 m length, 40 t gross weight)."
    },
    "CostingKind": {
      "oneOf": [
        {
          "type": "string",
          "const": "auto",
          "description": "Standard car costing."
        },
        {
          "type": "string",
          "const": "truck",
          "description": "Truck costing; honours dimensional limits and, when a `truck`\nprofile is supplied, ADR dangerous-goods restrictions."
        },
        {
          "type": "string",
          "const": "bicycle",
          "description": "Bicycle costing; tune it with a `bicycle` options object."
        },
        {
          "type": "string",
          "const": "pedestrian",
          "description": "Pedestrian (walking) costing; tune it with a `pedestrian` options\nobject (lit streets, wheelchair/blind, hiking difficulty)."
        },
        {
          "type": "string",
          "const": "motor_scooter",
          "description": "Motor scooter (moped) costing: like auto but prefers lower-speed\nroads and may use ways closed to larger motor vehicles."
        }
      ],
      "description": "Costing models exposed by the MCP tools (a deliberate subset of the\nValhalla costing list), serialised in snake_case exactly as Valhalla\nnames them."
    },
    "ReloadsSpec": {
      "type": "object",
      "required": [
        "max_trips"
      ],
      "properties": {
        "depot": {
          "anyOf": [
            {
              "$ref": "#/$defs/LatLon"
            },
            {
              "type": "null"
            }
          ],
          "description": "Where the vehicle reloads. Omitted, its own `start` is used (or its\n`end` if it declared only that)."
        },
        "max_trips": {
          "type": "integer",
          "format": "uint32",
          "minimum": 0,
          "description": "How many trips this vehicle may run in its shift, 2–5. A BUDGET,\nnot a prediction: the shift is cut into that many fixed windows\nbefore the solve, so asking for five trips on a shift that supports\nthree shrinks every window to a fifth and can make the whole day\nworse. Ask for the number of trips you actually expect to run."
        },
        "reload_time_s": {
          "type": [
            "integer",
            "null"
          ],
          "format": "uint32",
          "minimum": 0,
          "description": "Seconds at the depot between trips, tipping, reloading, the\nweighbridge. Held out of the shift before it is partitioned, so it\nis never accidentally spent driving."
        }
      },
      "description": "A vehicle's multi-trip reload plan."
    },
    "EmissionsFuel": {
      "oneOf": [
        {
          "type": "string",
          "const": "petrol",
          "description": "Petrol, including petrol hybrids (schemes rate a hybrid by its\ncombustion engine's approval)."
        },
        {
          "type": "string",
          "const": "diesel",
          "description": "Diesel, including diesel hybrids."
        },
        {
          "type": "string",
          "const": "electric",
          "description": "Battery-electric."
        },
        {
          "type": "string",
          "const": "hydrogen",
          "description": "Hydrogen fuel cell."
        },
        {
          "type": "string",
          "const": "gas",
          "description": "LPG or CNG; rated as petrol by every scheme in the dataset."
        }
      ],
      "description": "What a vehicle burns, in clean-air-zone scheme terms."
    },
    "EmissionsSpec": {
      "type": "object",
      "required": [
        "vehicle_category",
        "fuel"
      ],
      "properties": {
        "fuel": {
          "$ref": "#/$defs/EmissionsFuel",
          "description": "What it burns."
        },
        "euro_standard": {
          "type": [
            "integer",
            "null"
          ],
          "format": "uint8",
          "maximum": 255,
          "minimum": 0,
          "description": "Its Euro emission standard, 1–6. Heavy-duty approvals are written\nin Roman numerals (Euro VI); declare Euro VI as `6`. Required for\nany combustion fuel, without it no zone can be resolved, and a\nhalf-declared vehicle is indistinguishable from an undeclared one.\nOptional only for `electric` or `hydrogen`."
        },
        "vehicle_category": {
          "$ref": "#/$defs/EmissionsVehicleCategory",
          "description": "What kind of vehicle this is, in scheme terms."
        }
      },
      "description": "A vehicle's emission declaration, for clean-air / low-emission zone\nassessment."
    },
    "TerritorySpec": {
      "type": "object",
      "required": [
        "id",
        "polygon"
      ],
      "properties": {
        "id": {
          "type": "string",
          "description": "Caller-chosen id, echoed back and referenced by\n`vehicles[].territory_ids`. Must be unique within the request."
        },
        "polygon": {
          "type": "array",
          "items": {
            "type": "array",
            "items": {
              "type": "number",
              "format": "double"
            },
            "maxItems": 2,
            "minItems": 2
          },
          "description": "The outer ring as GeoJSON `[lon, lat]` positions, longitude\nFIRST. Closed or open; an unclosed ring is closed for you."
        }
      },
      "description": "One named territory: a polygon that bounds which vehicle may serve\nwhich stop."
    },
    "OptimiseJobSpec": {
      "type": "object",
      "required": [
        "id",
        "location"
      ],
      "properties": {
        "id": {
          "type": "integer",
          "format": "uint64",
          "minimum": 0,
          "description": "Caller-chosen job id, echoed back in steps and `unassigned`."
        },
        "pickup": {
          "type": [
            "array",
            "null"
          ],
          "items": {
            "type": "integer",
            "format": "int64"
          },
          "description": "Quantities picked up at the job (matches vehicle `capacity`)."
        },
        "skills": {
          "type": [
            "array",
            "null"
          ],
          "items": {
            "type": "integer",
            "format": "uint32",
            "minimum": 0
          },
          "description": "Skills the job requires."
        },
        "delivery": {
          "type": [
            "array",
            "null"
          ],
          "items": {
            "type": "integer",
            "format": "int64"
          },
          "description": "Quantities delivered to the job (matches vehicle `capacity`)."
        },
        "location": {
          "$ref": "#/$defs/LatLon",
          "description": "Job location."
        },
        "service_s": {
          "type": [
            "integer",
            "null"
          ],
          "format": "uint32",
          "minimum": 0,
          "description": "On-site service time in seconds."
        },
        "time_windows": {
          "type": [
            "array",
            "null"
          ],
          "items": {
            "type": "array",
            "items": {
              "type": "integer",
              "format": "int64"
            }
          },
          "description": "Acceptable `[start, end]` windows in seconds."
        }
      },
      "description": "One single-stop job of an optimisation problem."
    },
    "ReplanChangesSpec": {
      "type": "object",
      "properties": {
        "add_jobs": {
          "type": "array",
          "items": {
            "$ref": "#/$defs/OptimiseJobSpec"
          },
          "description": "New single-stop jobs, in exactly the `optimise_routes` job shape."
        },
        "add_shipments": {
          "type": "array",
          "items": {
            "$ref": "#/$defs/OptimiseShipmentSpec"
          },
          "description": "New pickup+delivery pairs, in exactly the `optimise_routes`\nshipment shape."
        },
        "cancel_job_ids": {
          "type": "array",
          "items": {
            "type": "integer",
            "format": "uint64",
            "minimum": 0
          },
          "description": "Ids of jobs that no longer need doing. A job already reported\ncompleted cannot be cancelled; the response says so rather than\nsilently dropping it."
        }
      },
      "description": "What has changed about the work since the plan was made."
    },
    "ReplanProgressSpec": {
      "type": "object",
      "required": [
        "vehicle"
      ],
      "properties": {
        "vehicle": {
          "type": "integer",
          "format": "uint64",
          "minimum": 0,
          "description": "The vehicle this progress belongs to, an `id` from `vehicles`."
        },
        "unavailable": {
          "type": [
            "boolean",
            "null"
          ],
          "description": "The vehicle has dropped out of the shift, breakdown, illness, end\nof hours. It leaves the fleet for the re-plan; what it already\ncompleted stays completed."
        },
        "current_position": {
          "anyOf": [
            {
              "$ref": "#/$defs/LatLon"
            },
            {
              "type": "null"
            }
          ],
          "description": "Where the vehicle is now; becomes its start for the re-plan.\nOmitted, its last completed stop is used; with neither, its\noriginal start."
        },
        "completed_stop_ids": {
          "type": "array",
          "items": {
            "type": "integer",
            "format": "uint64",
            "minimum": 0
          },
          "description": "Ids of the stops this vehicle has already served, IN THE ORDER IT\nSERVED THEM. Each is a job id or a shipment pickup/delivery id.\nThis is the locked prefix: it already happened, so no re-plan may\nmove it."
        }
      },
      "description": "One vehicle's progress through its shift."
    },
    "OptimiseVehicleSpec": {
      "type": "object",
      "required": [
        "id"
      ],
      "properties": {
        "id": {
          "type": "integer",
          "format": "uint64",
          "minimum": 0,
          "description": "Caller-chosen vehicle id, echoed back on its route."
        },
        "end": {
          "anyOf": [
            {
              "$ref": "#/$defs/LatLon"
            },
            {
              "type": "null"
            }
          ],
          "description": "End location; omitted, the route ends at its last stop."
        },
        "start": {
          "anyOf": [
            {
              "$ref": "#/$defs/LatLon"
            },
            {
              "type": "null"
            }
          ],
          "description": "Start location; at least one of `start`/`end` is required."
        },
        "skills": {
          "type": [
            "array",
            "null"
          ],
          "items": {
            "type": "integer",
            "format": "uint32",
            "minimum": 0
          },
          "description": "Skills this vehicle provides."
        },
        "reloads": {
          "anyOf": [
            {
              "$ref": "#/$defs/ReloadsSpec"
            },
            {
              "type": "null"
            }
          ],
          "description": "Let this vehicle return to a depot, reload and go out again, the\nwaste-collection tipping round, the van that comes back for a\nsecond wave of parcels."
        },
        "capacity": {
          "type": [
            "array",
            "null"
          ],
          "items": {
            "type": "integer",
            "format": "int64"
          },
          "description": "Multidimensional capacity (same length as job `delivery`/`pickup`)."
        },
        "time_window": {
          "type": [
            "array",
            "null"
          ],
          "items": {
            "type": "integer",
            "format": "int64"
          },
          "description": "Working window as `[start, end]` in seconds (any consistent epoch)."
        },
        "territory_ids": {
          "type": [
            "array",
            "null"
          ],
          "items": {
            "type": "string"
          },
          "description": "Ids of the request's `territories` this vehicle may work in.\nOmitted or empty, the vehicle is UNRESTRICTED and may serve any\ntask, inside a territory or outside every one of them. Listed, the\nvehicle may serve a task only if that task sits inside at least one\nof the named territories."
        }
      },
      "description": "One vehicle of an optimisation fleet."
    },
    "OptimiseShipmentSpec": {
      "type": "object",
      "required": [
        "pickup",
        "delivery"
      ],
      "properties": {
        "amount": {
          "type": [
            "array",
            "null"
          ],
          "items": {
            "type": "integer",
            "format": "int64"
          },
          "description": "Quantities moved (matches vehicle `capacity`)."
        },
        "pickup": {
          "$ref": "#/$defs/OptimiseShipmentStopSpec",
          "description": "The pickup end."
        },
        "skills": {
          "type": [
            "array",
            "null"
          ],
          "items": {
            "type": "integer",
            "format": "uint32",
            "minimum": 0
          },
          "description": "Skills the shipment requires."
        },
        "delivery": {
          "$ref": "#/$defs/OptimiseShipmentStopSpec",
          "description": "The delivery end."
        }
      },
      "description": "A pickup+delivery pair that must ride the same vehicle, pickup first."
    },
    "EmissionsVehicleCategory": {
      "oneOf": [
        {
          "type": "string",
          "const": "car",
          "description": "A private car."
        },
        {
          "type": "string",
          "const": "van",
          "description": "A van or light goods vehicle up to 3.5 tonnes."
        },
        {
          "type": "string",
          "const": "minibus",
          "description": "A minibus (typically 8+ passenger seats, up to 5 tonnes)."
        },
        {
          "type": "string",
          "const": "hgv",
          "description": "A heavy goods vehicle over 3.5 tonnes."
        },
        {
          "type": "string",
          "const": "bus",
          "description": "A bus over 5 tonnes."
        },
        {
          "type": "string",
          "const": "coach",
          "description": "A coach over 5 tonnes."
        },
        {
          "type": "string",
          "const": "taxi",
          "description": "A licensed hackney carriage."
        },
        {
          "type": "string",
          "const": "phv",
          "description": "A private hire vehicle."
        },
        {
          "type": "string",
          "const": "motorcycle",
          "description": "A motorcycle, moped or tricycle."
        },
        {
          "type": "string",
          "const": "motorhome",
          "description": "A motor caravan or campervan."
        }
      ],
      "description": "What a vehicle is, in clean-air-zone scheme terms.\n\nDeclaring this turns \"charge depends on vehicle emissions\" into an\nanswer. Without it a zone can only be named, never priced."
    },
    "OptimiseShipmentStopSpec": {
      "type": "object",
      "required": [
        "id",
        "location"
      ],
      "properties": {
        "id": {
          "type": "integer",
          "format": "uint64",
          "minimum": 0,
          "description": "Caller-chosen stop id, echoed back in steps and `unassigned`."
        },
        "location": {
          "$ref": "#/$defs/LatLon",
          "description": "Stop location."
        },
        "service_s": {
          "type": [
            "integer",
            "null"
          ],
          "format": "uint32",
          "minimum": 0,
          "description": "On-site service time in seconds."
        }
      },
      "description": "One end (pickup or delivery) of a shipment."
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "vehicles"
  ],
  "properties": {
    "jobs": {
      "type": "array",
      "items": {
        "$ref": "#/$defs/OptimiseJobSpec"
      },
      "description": "Single-stop jobs (at least one job or shipment overall)."
    },
    "truck": {
      "anyOf": [
        {
          "$ref": "#/$defs/TruckSpec"
        },
        {
          "type": "null"
        }
      ],
      "description": "Truck profile (dimensions + ADR declaration). Requires costing\n\"truck\"; the travel-time matrix then respects dimensional and\ndangerous-goods restrictions, so the whole plan is truck-legal."
    },
    "changes": {
      "anyOf": [
        {
          "$ref": "#/$defs/ReplanChangesSpec"
        },
        {
          "type": "null"
        }
      ],
      "description": "Changes to the work itself. Optional, on the same condition."
    },
    "costing": {
      "$ref": "#/$defs/CostingKind",
      "default": "auto",
      "description": "Costing model for the travel-time matrix: \"auto\" (default),\n\"truck\", \"bicycle\", \"pedestrian\" or \"motor_scooter\"."
    },
    "progress": {
      "type": "array",
      "items": {
        "$ref": "#/$defs/ReplanProgressSpec"
      },
      "description": "Per-vehicle progress. Optional, but at least one progress entry or\none change is required, a re-plan that reports nothing new is the\noriginal problem."
    },
    "vehicles": {
      "type": "array",
      "items": {
        "$ref": "#/$defs/OptimiseVehicleSpec"
      },
      "description": "The fleet (at least one vehicle, each with a start and/or end)."
    },
    "emissions": {
      "anyOf": [
        {
          "$ref": "#/$defs/EmissionsSpec"
        },
        {
          "type": "null"
        }
      ],
      "description": "The fleet's emission declaration, for UK clean-air / low-emission\nzone assessment. On its own it annotates: the response's `zones`\nblock names every zone containing one of the problem's own\nlocations and what this vehicle would pay there. With\n`avoid_zones` it also steers the internal travel-time matrix away\nfrom those zones, so the plan itself changes."
    },
    "shipments": {
      "type": "array",
      "items": {
        "$ref": "#/$defs/OptimiseShipmentSpec"
      },
      "description": "Pickup+delivery pairs."
    },
    "avoid_zones": {
      "type": [
        "boolean",
        "null"
      ],
      "description": "Keep the optimisation's travel-time matrix out of every zone the\ndeclared vehicle would be charged or banned in. Requires\n`emissions`."
    },
    "territories": {
      "type": [
        "array",
        "null"
      ],
      "items": {
        "$ref": "#/$defs/TerritorySpec"
      },
      "description": "Fleet territories: named polygons that bound which vehicle may\nserve which stop, referenced by `vehicles[].territory_ids`. These\nare request data, caller-drawn rounds, validated per call and\nnever stored. Nothing to do with clean-air zones or with the\noffline map packages of the same word."
    },
    "relax_if_unassigned": {
      "anyOf": [
        {
          "$ref": "#/$defs/RelaxSpec"
        },
        {
          "type": "null"
        }
      ],
      "description": "Re-solve ONCE with these relaxations if the first solve leaves work\nunassigned, and say honestly which plan came back. At most one\nsecond solve, never beyond the caps you state, and the relaxed plan\nis returned only if it assigns MORE work than the first, giving\naway constraints for nothing is strictly worse than not giving them\naway. Breaks are never widened, nor are capacities, skills,\nterritories or task caps: only time windows move, and only by the\nstated amounts. Bills as two solves when the second one runs."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "lat",
    "lon"
  ],
  "properties": {
    "lat": {
      "type": "number",
      "format": "double",
      "description": "Latitude in decimal degrees (−90 to 90)."
    },
    "lon": {
      "type": "number",
      "format": "double",
      "description": "Longitude in decimal degrees (−180 to 180)."
    },
    "limit": {
      "type": [
        "integer",
        "null"
      ],
      "format": "uint32",
      "minimum": 0,
      "description": "Maximum number of results (1–10, default 5). The hosted\nfirst-party index answers at most 5 nearest hits per lookup."
    },
    "fov_deg": {
      "type": [
        "number",
        "null"
      ],
      "format": "double",
      "description": "Field of view: the full width in degrees of a cone centred on\n`heading_deg`, outside which results are dropped, it is the\nFULL width, so 90 keeps only what lies within 45 degrees either\nside of dead ahead. Needs\n`heading_deg`, a cone has to point somewhere. The count of\nresults removed is reported as `out_of_view`."
    },
    "heading_deg": {
      "type": [
        "number",
        "null"
      ],
      "format": "double",
      "description": "Which way the user is facing, in degrees **clockwise from true\nnorth** (0 = north, 90 = east, 180 = south, 270 = west). Supply it\nand every result is also described from the user's point of view\n(\"just ahead on your right\"); omit it and results fall back to\ncardinal directions (\"to the north-east\"), so the tool works with\nor without a compass."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "geometry_polyline6"
  ],
  "properties": {
    "units": {
      "type": [
        "string",
        "null"
      ],
      "description": "Units for the spoken distances: `miles` (default) or\n`kilometers`. `kilometres` and `km` are accepted too."
    },
    "min_gap_m": {
      "type": [
        "number",
        "null"
      ],
      "format": "double",
      "description": "Least distance along the route between two observations, metres\n(default 2000). A FLOOR, not a target: when the route holds more\nthan `max_observations`, the gap widens past this on its own so\nthe survivors stay spread over the whole journey."
    },
    "max_observations": {
      "type": [
        "integer",
        "null"
      ],
      "format": "uint32",
      "minimum": 0,
      "description": "Ceiling on how many observations come back, 1 to 200 (default\n40)."
    },
    "geometry_polyline6": {
      "type": "string",
      "description": "The route shape, precision-6 encoded: `geometry_polyline6`\nstraight out of the `route` tool's answer. Nothing else is\naccepted: there is no origin/destination form, because this tool\nannotates a route somebody already chose rather than computing\none."
    }
  }
}

{
  "type": "object",
  "$defs": {
    "LatLon": {
      "anyOf": [
        {
          "type": "object",
          "required": [
            "lat",
            "lon"
          ],
          "properties": {
            "lat": {
              "type": "number",
              "format": "double",
              "description": "Latitude in decimal degrees (−90 to 90)."
            },
            "lon": {
              "type": "number",
              "format": "double",
              "description": "Longitude in decimal degrees (−180 to 180)."
            }
          }
        },
        {
          "type": "array",
          "items": {
            "type": "number",
            "format": "double"
          },
          "maxItems": 2,
          "minItems": 2,
          "description": "GeoJSON position [lon, lat]: longitude FIRST."
        }
      ],
      "description": "A WGS84 coordinate in decimal degrees: a {lat, lon} object (preferred), or a GeoJSON [lon, lat] array with LONGITUDE FIRST, the same order as every polygon field on this server."
    },
    "TruckSpec": {
      "type": "object",
      "properties": {
        "hazmat": {
          "type": "boolean",
          "default": false,
          "description": "Whether the vehicle carries dangerous goods (ADR). Defaults to\nfalse."
        },
        "width_m": {
          "type": [
            "number",
            "null"
          ],
          "format": "double",
          "description": "Vehicle width in metres."
        },
        "height_m": {
          "type": [
            "number",
            "null"
          ],
          "format": "double",
          "description": "Vehicle height in metres."
        },
        "length_m": {
          "type": [
            "number",
            "null"
          ],
          "format": "double",
          "description": "Vehicle length in metres."
        },
        "tunnel_code": {
          "type": [
            "string",
            "null"
          ],
          "description": "ADR 8.6.4 tunnel restriction code of the load, e.g. \"B\", \"C5000D\",\n\"B/D\", or \"(-)\"/\"none\" for explicitly unrestricted. Leave unset if\nunknown: a hazmat load without a code is conservatively treated as\ncode B (allowed only through category-A tunnels)."
        },
        "gross_weight_t": {
          "type": [
            "number",
            "null"
          ],
          "format": "double",
          "description": "Gross combination weight in metric tonnes."
        }
      },
      "description": "Truck profile for routing: physical dimensions plus the ADR\ndangerous-goods declaration. Omitted dimensions default to the EU\nmaximum authorised dimensions of Council Directive 96/53/EC (4.0 m\nheight, 2.55 m width, 16.5 m length, 40 t gross weight)."
    },
    "CostingKind": {
      "oneOf": [
        {
          "type": "string",
          "const": "auto",
          "description": "Standard car costing."
        },
        {
          "type": "string",
          "const": "truck",
          "description": "Truck costing; honours dimensional limits and, when a `truck`\nprofile is supplied, ADR dangerous-goods restrictions."
        },
        {
          "type": "string",
          "const": "bicycle",
          "description": "Bicycle costing; tune it with a `bicycle` options object."
        },
        {
          "type": "string",
          "const": "pedestrian",
          "description": "Pedestrian (walking) costing; tune it with a `pedestrian` options\nobject (lit streets, wheelchair/blind, hiking difficulty)."
        },
        {
          "type": "string",
          "const": "motor_scooter",
          "description": "Motor scooter (moped) costing: like auto but prefers lower-speed\nroads and may use ways closed to larger motor vehicles."
        }
      ],
      "description": "Costing models exposed by the MCP tools (a deliberate subset of the\nValhalla costing list), serialised in snake_case exactly as Valhalla\nnames them."
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "query"
  ],
  "properties": {
    "query": {
      "type": "string",
      "description": "Free-text POI query, e.g. \"coffee\", \"EV charger\", \"truck stop\"."
    },
    "truck": {
      "anyOf": [
        {
          "$ref": "#/$defs/TruckSpec"
        },
        {
          "type": "null"
        }
      ],
      "description": "Truck profile (dimensions + ADR declaration). Requires costing\n\"truck\"; the detours then respect dimensional/ADR restrictions."
    },
    "origin": {
      "anyOf": [
        {
          "$ref": "#/$defs/LatLon"
        },
        {
          "type": "null"
        }
      ],
      "description": "Route origin (with `destination`, when no geometry is given)."
    },
    "costing": {
      "$ref": "#/$defs/CostingKind",
      "default": "auto",
      "description": "Costing model for the route and detour matrix: \"auto\" (default),\n\"truck\", \"bicycle\", \"pedestrian\" or \"motor_scooter\"."
    },
    "category": {
      "type": [
        "string",
        "null"
      ],
      "description": "Explicit place category (\"fuel\", \"cafe\", \"charging_station\", same\nvocabulary as nearby_places). Colloquial phrases are normalised\nserver-side; prefer this over query for category intents."
    },
    "destination": {
      "anyOf": [
        {
          "$ref": "#/$defs/LatLon"
        },
        {
          "type": "null"
        }
      ],
      "description": "Route destination."
    },
    "max_results": {
      "type": [
        "integer",
        "null"
      ],
      "format": "uint32",
      "minimum": 0,
      "description": "Maximum results (default 5, at most 25)."
    },
    "geometry_polyline6": {
      "type": [
        "string",
        "null"
      ],
      "description": "An existing route geometry as an encoded polyline6 (the `route`\ntool's `geometry_polyline6`). Provide either this or `origin` +\n`destination`, not both."
    },
    "max_detour_minutes": {
      "type": [
        "number",
        "null"
      ],
      "format": "double",
      "description": "Largest acceptable detour in minutes (default 10, at most 120)."
    }
  },
  "additionalProperties": false
}

{
  "type": "object",
  "$defs": {
    "RetroProblemArea": {
      "oneOf": [
        {
          "type": "string",
          "const": "sdk",
          "description": "The mobile/web SDKs."
        },
        {
          "type": "string",
          "const": "api",
          "description": "The hosted HTTP API."
        },
        {
          "type": "string",
          "const": "mcp",
          "description": "The MCP tool surface."
        },
        {
          "type": "string",
          "const": "docs",
          "description": "Documentation."
        },
        {
          "type": "string",
          "const": "billing",
          "description": "Billing, keys or quotas."
        },
        {
          "type": "string",
          "const": "self-host",
          "description": "Self-hosted deployment."
        },
        {
          "type": "string",
          "const": "other",
          "description": "Anything else."
        }
      ],
      "description": "The platform area an integration problem belongs to (mirrors the\ngateway's `POST /v1/feedback` schema)."
    },
    "RetroProblemInput": {
      "type": "object",
      "required": [
        "area",
        "description",
        "workaround_found"
      ],
      "properties": {
        "area": {
          "$ref": "#/$defs/RetroProblemArea",
          "description": "Which part of the platform the problem was in."
        },
        "description": {
          "type": "string",
          "description": "What went wrong (at most 1000 bytes)."
        },
        "workaround_found": {
          "type": "boolean",
          "description": "Whether a workaround was found."
        }
      },
      "description": "One problem hit during the integration."
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "what_built"
  ],
  "properties": {
    "wins": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "default": [],
      "description": "What went well (at most 20 entries × 500 bytes)."
    },
    "gotchas": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "default": [],
      "description": "Surprises/traps worth documenting (at most 20 entries × 500 bytes)."
    },
    "problems": {
      "type": "array",
      "items": {
        "$ref": "#/$defs/RetroProblemInput"
      },
      "default": [],
      "description": "Problems hit during the integration (at most 20)."
    },
    "docs_gaps": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "default": [],
      "description": "Documentation gaps hit (at most 20 entries × 500 bytes)."
    },
    "agent_name": {
      "type": [
        "string",
        "null"
      ],
      "description": "The submitting agent's name, e.g. \"Claude Code\" (at most 100\nbytes)."
    },
    "what_built": {
      "type": "string",
      "description": "What was built with MapMap, in one or two sentences (required, at\nmost 500 bytes)."
    },
    "sdk_version": {
      "type": [
        "string",
        "null"
      ],
      "description": "MapMap SDK version integrated against, when known (at most 50\nbytes)."
    }
  }
}

{
  "type": "object",
  "$defs": {
    "JobKind": {
      "oneOf": [
        {
          "type": "string",
          "const": "optimise",
          "description": "A fleet optimisation, the `optimise_routes` problem, at ten times\nthe synchronous location cap."
        },
        {
          "type": "string",
          "const": "replan",
          "description": "A mid-shift re-plan, the `replan_routes` problem, counted on the\nremaining work."
        },
        {
          "type": "string",
          "const": "matrix",
          "description": "A many-to-many time/distance matrix, the `matrix` problem, at four\ntimes the synchronous element cap."
        }
      ],
      "description": "Which asynchronous problem is being submitted."
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "kind",
    "problem"
  ],
  "properties": {
    "kind": {
      "$ref": "#/$defs/JobKind",
      "description": "Which problem this is. It selects both the body shape below and the\nceiling the submission is judged against."
    },
    "problem": {
      "description": "The problem itself, in exactly the shape the synchronous tool takes\n, `optimise_routes` input for `optimise`, `replan_routes` input for\n`replan`, `matrix` input for `matrix`. Moving a working synchronous\ncall onto this lane changes nothing but the tool you call it with."
    },
    "webhook_url": {
      "type": [
        "string",
        "null"
      ],
      "description": "Optional HTTPS URL to POST a signed `{job_id, kind, status,\nresult_url}` notification to when the job finishes. The RESULT is\nnever pushed, the notification says where to fetch it. Requires a\nwebhook signing secret on the key; without one the submission is\nrefused rather than delivered unsigned. An agent that can poll does\nnot need this: polling with `get_job` is free."
    }
  }
}

{
  "type": "object",
  "$defs": {
    "CostingKind": {
      "oneOf": [
        {
          "type": "string",
          "const": "auto",
          "description": "Standard car costing."
        },
        {
          "type": "string",
          "const": "truck",
          "description": "Truck costing; honours dimensional limits and, when a `truck`\nprofile is supplied, ADR dangerous-goods restrictions."
        },
        {
          "type": "string",
          "const": "bicycle",
          "description": "Bicycle costing; tune it with a `bicycle` options object."
        },
        {
          "type": "string",
          "const": "pedestrian",
          "description": "Pedestrian (walking) costing; tune it with a `pedestrian` options\nobject (lit streets, wheelchair/blind, hiking difficulty)."
        },
        {
          "type": "string",
          "const": "motor_scooter",
          "description": "Motor scooter (moped) costing: like auto but prefers lower-speed\nroads and may use ways closed to larger motor vehicles."
        }
      ],
      "description": "Costing models exposed by the MCP tools (a deliberate subset of the\nValhalla costing list), serialised in snake_case exactly as Valhalla\nnames them."
    },
    "VerifyClaimInput": {
      "type": "object",
      "required": [
        "name"
      ],
      "properties": {
        "id": {
          "type": [
            "string",
            "null"
          ],
          "description": "Caller-chosen id, echoed back on the matching result. Auto-assigned\n(\"claim-1\", …) when omitted."
        },
        "name": {
          "type": "string",
          "description": "The place name as claimed, e.g. \"The Eagle and Child\"."
        },
        "locality": {
          "type": [
            "string",
            "null"
          ],
          "description": "Optional disambiguating context, e.g. \"Oxford\". Country-level words\n(\"UK\", \"England\", …) are stripped before querying, they add noise,\nnot signal, to name search."
        },
        "sequence": {
          "type": [
            "integer",
            "null"
          ],
          "format": "int64",
          "description": "Itinerary position. Claims that share increasing `sequence` values\nand both carry `claimed_time` form legs the feasibility pass checks."
        },
        "claimed_time": {
          "type": [
            "string",
            "null"
          ],
          "description": "ISO 8601 timestamp: when the itinerary claims you are at this place."
        }
      },
      "description": "One place claim for the `verify_places` tool: a place an AI mentioned,\nto be checked for existence and (as part of an itinerary) feasibility.\n\nUnknown fields are refused, naming the accepted ones. A dev-lane run\n(19 Oct 2026) passed `near` instead of `locality`; it was silently\ndropped, \"Roman Baths\" matched Ankara, and the itinerary leg became\nuncomputable with nothing telling the caller why.",
      "additionalProperties": false
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "text": {
      "type": [
        "string",
        "null"
      ],
      "description": "Free text to extract place claims from (best-effort heuristic:\nquoted phrases and Title Case runs after \"at/in/near/to/from/\nvisiting\", not NLP or an LLM call, and it does not attempt\nitinerary feasibility since there are no explicit times to anchor\nlegs to). Mutually exclusive with `claims`. Max 8,000 characters."
    },
    "claims": {
      "type": [
        "array",
        "null"
      ],
      "items": {
        "$ref": "#/$defs/VerifyClaimInput"
      },
      "description": "Structured claims, the reliable path, and the only path that\nsupports itinerary feasibility. Mutually exclusive with `text`.\nMax 20 per request."
    },
    "costing": {
      "$ref": "#/$defs/CostingKind",
      "default": "auto",
      "description": "Costing for feasibility legs: \"auto\" (default), \"truck\", \"bicycle\",\n\"pedestrian\" or \"motor_scooter\"."
    }
  },
  "additionalProperties": false
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "shape"
  ],
  "properties": {
    "shape": {
      "type": "string",
      "description": "The route shape as an encoded polyline6 (the `route` tool's\n`geometry_polyline6`)."
    },
    "depart_at": {
      "type": [
        "string",
        "null"
      ],
      "description": "Departure time, RFC 3339 (e.g. \"2026-10-12T14:00:00Z\"); defaults to\nnow. Forecasts reach about 16 days ahead; samples past that answer\nunavailable."
    },
    "duration_s": {
      "type": [
        "number",
        "null"
      ],
      "format": "double",
      "description": "The route's duration in seconds, used to work out when you reach\neach sample. Pass the `route` tool's duration; omitted, a generic\n80 km/h average is assumed and `duration_source` says so."
    },
    "sample_interval_m": {
      "type": [
        "number",
        "null"
      ],
      "format": "double",
      "description": "Distance between samples in metres (default 25,000, clamped to\n5,000 to 100,000; at most 40 samples per route)."
    }
  }
}