Files
gods-eye-view/src/tools/places.js
T
quanticsoul4772andClaude Opus 5.5 1bff1961b4 fix(routes): keep the 12 s budget from arrival and name the outage to voice
Starting the upstream timeout after the outbound queue let a request run
up to about 19 s, past the Directions layer's 15 s; the budget again runs
from arrival, queue wait included, and a budget spent before the request
leaves the queue answers 429 "routing busy" rather than an outage.

plan_route threw "Routing HTTP 502" for an outage, and voice passes only
the message on; it now throws "Routing service unavailable (HTTP 502)".

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-02 09:21:08 -08:00

218 lines
7.1 KiB
JavaScript

/**
* Place services backed by the app's own routes. Applications with different
* providers can supply any objects with the same contracts:
*
* - `places.resolve(name, { signal })` turns a name into bounds (`/api/geocode`).
* - `placeSearch.search(query, near, { signal })` and
* `placeSearch.nearby(near, { signal })` find points of interest
* (`/api/google/*`), reporting whether search is configured.
* - `routing.route(points, profile, { signal })` plans a route (`/api/route`).
*/
import { ToolError } from './catalog.js';
const POINT_RADIUS_DEGREES = 0.25;
/**
* Resolve place names to `{ name, bounds: { west, south, east, north }, point }`
* or null. `point` is the place's own location, which can lie far from the
* middle of its bounds (a region with remote islands, for example).
*/
export function createGeocodePlaceService({
fetchImpl = (...args) => globalThis.fetch(...args),
cacheSize = 200,
cacheMs = 10 * 60_000,
timeoutMs = 15_000,
now = () => Date.now(),
} = {}) {
// Recent answers by name, so tools that combine others resolve a place to
// the same point once instead of once per section. A pending lookup is
// shared by its callers: it has its own deadline, is cancelled when every
// caller has given up, and only a successful answer stays cached.
const cache = new Map();
async function lookup(name, signal) {
const query = new URLSearchParams({ q: name });
const response = await fetchImpl(`/api/geocode?${query}`, { signal });
if (!response.ok) throw new Error(`Geocode HTTP ${response.status}`);
const payload = await response.json();
return placeFromGeocodeResult(payload?.results?.[0]);
}
function start(key, name) {
const controller = new AbortController();
const entry = {
at: now(),
controller,
waiters: 0,
settled: false,
place: lookup(
name,
AbortSignal.any([controller.signal, AbortSignal.timeout(timeoutMs)]),
),
};
entry.place.then(
() => {
entry.settled = true;
},
() => {
entry.settled = true;
if (cache.get(key) === entry) cache.delete(key);
},
);
cache.set(key, entry);
while (cache.size > cacheSize) cache.delete(cache.keys().next().value);
return entry;
}
function join(key, entry, signal) {
if (!signal) {
// A caller that cannot cancel keeps the lookup alive.
entry.waiters = Infinity;
return entry.place;
}
signal.throwIfAborted();
entry.waiters += 1;
return new Promise((resolve, reject) => {
const leave = () => {
entry.waiters -= 1;
reject(signal.reason);
if (entry.waiters <= 0 && !entry.settled) {
entry.controller.abort(signal.reason);
if (cache.get(key) === entry) cache.delete(key);
}
};
signal.addEventListener('abort', leave, { once: true });
entry.place
.then(resolve, reject)
.finally(() => signal.removeEventListener('abort', leave));
});
}
return {
async resolve(name, { signal } = {}) {
signal?.throwIfAborted();
const key = name.trim().toLowerCase();
let entry = cache.get(key);
if (entry && now() - entry.at < cacheMs) {
cache.delete(key);
cache.set(key, entry);
} else entry = start(key, name);
return join(key, entry, signal);
},
};
}
/** Convert one geocode result to a place with bounds, or null. */
export function placeFromGeocodeResult(result) {
const location = result?.geometry?.location;
if (!Number.isFinite(location?.lat) || !Number.isFinite(location?.lng))
return null;
const viewport = result.geometry.viewport;
const bounds =
viewport &&
[
viewport.southwest?.lat,
viewport.southwest?.lng,
viewport.northeast?.lat,
viewport.northeast?.lng,
].every(Number.isFinite)
? {
west: viewport.southwest.lng,
south: viewport.southwest.lat,
east: viewport.northeast.lng,
north: viewport.northeast.lat,
}
: {
west: Math.max(-180, location.lng - POINT_RADIUS_DEGREES),
south: Math.max(-90, location.lat - POINT_RADIUS_DEGREES),
east: Math.min(180, location.lng + POINT_RADIUS_DEGREES),
north: Math.min(90, location.lat + POINT_RADIUS_DEGREES),
};
return {
name: result.formatted_address || null,
bounds,
point: { lat: location.lat, lon: location.lng },
};
}
/** Search points of interest; `configured` is false when the server has no search key. */
export function createPlaceSearchService({
fetchImpl = (...args) => globalThis.fetch(...args),
} = {}) {
async function read(path, params, signal) {
const response = await fetchImpl(`${path}?${new URLSearchParams(params)}`, {
signal,
});
let payload = null;
try {
payload = await response.json();
} catch {
/* the status below is authoritative */
}
if (!response.ok) throw httpFailure(response, 'Place search');
return {
configured: payload?.configured !== false,
places: Array.isArray(payload?.places) ? payload.places : [],
};
}
return {
search(query, { latitude, longitude, radiusM }, { signal } = {}) {
return read(
'/api/google/text-search',
{ q: query, lat: latitude, lon: longitude, radiusM },
signal,
);
},
nearby({ latitude, longitude, radiusM }, { signal } = {}) {
return read(
'/api/google/nearby-places',
{ lat: latitude, lon: longitude, radiusM },
signal,
);
},
};
}
/** Plan routes between `[{ lat, lon }]` points; resolves `{ ok, ... }`. */
export function createRouteService({
fetchImpl = (...args) => globalThis.fetch(...args),
} = {}) {
return {
async route(points, profile, { signal } = {}) {
const coords = points
.map((point) => `${point.lon.toFixed(6)},${point.lat.toFixed(6)}`)
.join(';');
const response = await fetchImpl(
`/api/route?${new URLSearchParams({ profile, coords })}`,
{ signal },
);
let payload = null;
try {
payload = await response.json();
} catch {
/* the status below is authoritative */
}
// A rate limit or an outage (5xx) is the routing service's failure, not
// a missing route, whatever the body says. Voice hears this message.
if (response.status === 429) throw httpFailure(response, 'Routing');
if (response.status >= 500)
throw new ToolError(
'unavailable',
`Routing service unavailable (HTTP ${response.status})`,
);
if (payload?.ok === false || response.status === 400)
return { ok: false, error: payload?.error || 'no route found' };
if (!response.ok) throw httpFailure(response, 'Routing');
return payload;
},
};
}
function httpFailure(response, label) {
if (response.status === 429) {
const seconds = Number(response.headers.get('retry-after'));
return new ToolError('retry_later', `${label} is rate limited`, {
retryAfterSeconds:
Number.isFinite(seconds) && seconds > 0 ? seconds : null,
});
}
return new Error(`${label} HTTP ${response.status}`);
}