mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-17 08:42:21 +00:00
Preserve quanticsoul4772's routing-outage fix and add a focused voice-facing regression for a non-JSON gateway response.
363 lines
10 KiB
JavaScript
363 lines
10 KiB
JavaScript
import assert from 'node:assert/strict';
|
|
import test from 'node:test';
|
|
import { composeCatalog, coreTools } from '../index.js';
|
|
import { createMcpServer } from '../mcp/index.js';
|
|
import { createPlaceSearchService, createRouteService } from '../places.js';
|
|
|
|
const place = (id, latitude, longitude, extra = {}) => ({
|
|
id,
|
|
name: `Place ${id}`,
|
|
address: `${id} Main St`,
|
|
latitude,
|
|
longitude,
|
|
distanceM: 120,
|
|
primaryType: 'cafe',
|
|
types: ['cafe'],
|
|
...extra,
|
|
});
|
|
const placeSearch = (result) => ({
|
|
calls: [],
|
|
async search(query, near) {
|
|
this.calls.push({ query, ...near });
|
|
return result;
|
|
},
|
|
async nearby(near) {
|
|
this.calls.push(near);
|
|
return result;
|
|
},
|
|
});
|
|
const places = {
|
|
resolve: async (name) =>
|
|
({
|
|
Austin: {
|
|
name: 'Austin, Texas',
|
|
bounds: { west: -97.94, south: 30.1, east: -97.56, north: 30.52 },
|
|
},
|
|
Dallas: {
|
|
name: 'Dallas, Texas',
|
|
bounds: { west: -96.99, south: 32.62, east: -96.46, north: 33.02 },
|
|
},
|
|
})[name] ?? null,
|
|
};
|
|
|
|
test('place search is centered on the area, kept inside it, and reports a missing key', async () => {
|
|
const search = placeSearch({
|
|
configured: true,
|
|
places: [place('a', 30.27, -97.74), place('far', 40.7, -74)],
|
|
});
|
|
const catalog = composeCatalog({
|
|
tools: coreTools,
|
|
services: { placeSearch: search, places },
|
|
});
|
|
const result = await catalog.call('search_places', {
|
|
query: 'coffee',
|
|
area: { place: 'Austin' },
|
|
});
|
|
assert.equal(result.summary, '1 place matching "coffee" in Austin, Texas.');
|
|
assert.deepEqual(result.data.rows[0], {
|
|
id: 'a',
|
|
name: 'Place a',
|
|
address: 'a Main St',
|
|
type: 'cafe',
|
|
lat: 30.27,
|
|
lon: -97.74,
|
|
distance_m: 120,
|
|
});
|
|
assert.equal(search.calls[0].query, 'coffee');
|
|
assert.ok(Math.abs(search.calls[0].latitude - 30.31) < 1e-9);
|
|
assert.equal(search.calls[0].radiusM, 29642);
|
|
|
|
const unconfigured = composeCatalog({
|
|
tools: coreTools,
|
|
services: {
|
|
placeSearch: placeSearch({ configured: false, places: [] }),
|
|
places,
|
|
},
|
|
});
|
|
await assert.rejects(
|
|
unconfigured.call('search_places', {
|
|
query: 'coffee',
|
|
area: { place: 'Austin' },
|
|
}),
|
|
(error) =>
|
|
error.code === 'unavailable' && /Google Places key/.test(error.message),
|
|
);
|
|
});
|
|
|
|
test('nearby places use the given radius', async () => {
|
|
const search = placeSearch({
|
|
configured: true,
|
|
places: [place('a', 30.27, -97.74)],
|
|
});
|
|
const catalog = composeCatalog({
|
|
tools: coreTools,
|
|
services: { placeSearch: search },
|
|
});
|
|
const result = await catalog.call('places_nearby', {
|
|
location: { lat: 30.27, lon: -97.74 },
|
|
radius_m: 400,
|
|
});
|
|
assert.equal(result.summary, '1 place within 400 m of 30.2700, -97.7400.');
|
|
assert.deepEqual(search.calls[0], {
|
|
latitude: 30.27,
|
|
longitude: -97.74,
|
|
radiusM: 400,
|
|
});
|
|
});
|
|
|
|
test('routes resolve endpoints, map modes and thin long paths', async () => {
|
|
const requests = [];
|
|
const geometry = Array.from({ length: 250 }, (_, index) => [
|
|
-97.74 + index / 1000,
|
|
30.27,
|
|
]);
|
|
const routing = {
|
|
async route(points, profile) {
|
|
requests.push({ points, profile });
|
|
return {
|
|
ok: true,
|
|
profile,
|
|
distanceM: 312400,
|
|
durationS: 11220,
|
|
geometry,
|
|
};
|
|
},
|
|
};
|
|
const catalog = composeCatalog({
|
|
tools: coreTools,
|
|
services: { routing, places },
|
|
});
|
|
const result = await catalog.call('plan_route', {
|
|
from: { place: 'Austin' },
|
|
to: { lat: 32.78, lon: -96.8 },
|
|
mode: 'drive',
|
|
});
|
|
assert.equal(
|
|
result.summary,
|
|
'Drive from Austin, Texas to 32.7800, -96.8000: 312.4 km, about 187 minutes.',
|
|
);
|
|
assert.equal(requests[0].profile, 'car');
|
|
assert.deepEqual(requests[0].points[1], {
|
|
label: '32.7800, -96.8000',
|
|
lat: 32.78,
|
|
lon: -96.8,
|
|
});
|
|
assert.equal(result.data.path_points, 250);
|
|
assert.equal(result.data.path_lon_lat.length, 100);
|
|
assert.deepEqual(result.data.path_lon_lat.at(-1), [-97.491, 30.27]);
|
|
|
|
const failing = composeCatalog({
|
|
tools: coreTools,
|
|
services: {
|
|
routing: {
|
|
route: async () => ({ ok: false, error: 'route leg too long' }),
|
|
},
|
|
places,
|
|
},
|
|
});
|
|
await assert.rejects(
|
|
failing.call('plan_route', {
|
|
from: { place: 'Austin' },
|
|
to: { place: 'Dallas' },
|
|
}),
|
|
/No walk route from Austin, Texas to Dallas, Texas: route leg too long/,
|
|
);
|
|
await assert.rejects(
|
|
catalog.call('plan_route', {
|
|
from: { place: 'Austin', lat: 1 },
|
|
to: { lat: 1, lon: 2 },
|
|
}),
|
|
/either place, or lat and lon/,
|
|
);
|
|
});
|
|
|
|
test('the place and route services read the app routes and translate failures', async () => {
|
|
const requested = [];
|
|
const respond = (body, status = 200, headers = {}) =>
|
|
new Response(JSON.stringify(body), {
|
|
status,
|
|
headers: { 'Content-Type': 'application/json', ...headers },
|
|
});
|
|
const search = createPlaceSearchService({
|
|
fetchImpl: async (url) => {
|
|
requested.push(url);
|
|
return url.includes('nearby')
|
|
? respond({ configured: false, error: null, places: [] })
|
|
: respond({ places: [place('a', 1, 2)] });
|
|
},
|
|
});
|
|
assert.deepEqual(
|
|
await search.search('tea', { latitude: 1, longitude: 2, radiusM: 300 }),
|
|
{
|
|
configured: true,
|
|
places: [place('a', 1, 2)],
|
|
},
|
|
);
|
|
assert.deepEqual(
|
|
await search.nearby({ latitude: 1, longitude: 2, radiusM: 50 }),
|
|
{ configured: false, places: [] },
|
|
);
|
|
assert.deepEqual(requested, [
|
|
'/api/google/text-search?q=tea&lat=1&lon=2&radiusM=300',
|
|
'/api/google/nearby-places?lat=1&lon=2&radiusM=50',
|
|
]);
|
|
|
|
const limited = createPlaceSearchService({
|
|
fetchImpl: async () =>
|
|
respond({ error: 'Rate limit exceeded', places: [] }, 429, {
|
|
'Retry-After': '30',
|
|
}),
|
|
});
|
|
await assert.rejects(
|
|
limited.nearby({ latitude: 1, longitude: 2, radiusM: 50 }),
|
|
(error) => error.code === 'retry_later' && error.retryAfterSeconds === 30,
|
|
);
|
|
|
|
const routes = [];
|
|
const routing = createRouteService({
|
|
fetchImpl: async (url) => {
|
|
routes.push(url);
|
|
if (routes.length === 1)
|
|
return respond({
|
|
ok: true,
|
|
distanceM: 10,
|
|
durationS: 5,
|
|
geometry: [[2, 1]],
|
|
});
|
|
if (routes.length === 2)
|
|
return respond({ ok: false, error: 'need 2-12 coordinates' }, 400);
|
|
return respond({ ok: false, error: 'rate limited' }, 429, {
|
|
'Retry-After': '5',
|
|
});
|
|
},
|
|
});
|
|
const points = [
|
|
{ lat: 1, lon: 2 },
|
|
{ lat: 1.5, lon: 2.5 },
|
|
];
|
|
assert.equal((await routing.route(points, 'foot')).distanceM, 10);
|
|
assert.equal(
|
|
routes[0],
|
|
'/api/route?profile=foot&coords=2.000000%2C1.000000%3B2.500000%2C1.500000',
|
|
);
|
|
assert.deepEqual(await routing.route(points, 'foot'), {
|
|
ok: false,
|
|
error: 'need 2-12 coordinates',
|
|
});
|
|
await assert.rejects(
|
|
routing.route(points, 'foot'),
|
|
(error) => error.code === 'retry_later' && error.retryAfterSeconds === 5,
|
|
);
|
|
});
|
|
|
|
test('a routing outage is reported as unavailable, not as invalid arguments', async () => {
|
|
for (const fetchImpl of [
|
|
async () =>
|
|
Response.json(
|
|
{ ok: false, error: 'routing service unavailable' },
|
|
{ status: 502 },
|
|
),
|
|
async () => {
|
|
throw new TypeError('fetch failed');
|
|
},
|
|
]) {
|
|
const catalog = composeCatalog({
|
|
tools: coreTools,
|
|
services: { routing: createRouteService({ fetchImpl }), places },
|
|
});
|
|
const server = createMcpServer({
|
|
catalog,
|
|
name: 'test',
|
|
version: '1.0.0',
|
|
});
|
|
const { result } = await server.handle({
|
|
jsonrpc: '2.0',
|
|
id: 1,
|
|
method: 'tools/call',
|
|
params: {
|
|
name: 'plan_route',
|
|
arguments: { from: { place: 'Austin' }, to: { place: 'Dallas' } },
|
|
},
|
|
});
|
|
assert.equal(result.isError, true);
|
|
assert.equal(result.structuredContent.error, 'unavailable');
|
|
assert.doesNotMatch(result.content[0].text, /No walk route/);
|
|
}
|
|
// Voice receives only the message, so it must name the outage.
|
|
const outage = createRouteService({
|
|
fetchImpl: async () =>
|
|
Response.json(
|
|
{ ok: false, error: 'routing service unavailable' },
|
|
{ status: 502 },
|
|
),
|
|
});
|
|
await assert.rejects(
|
|
outage.route(
|
|
[
|
|
{ lat: 30, lon: -97 },
|
|
{ lat: 30.01, lon: -97.01 },
|
|
],
|
|
'foot',
|
|
),
|
|
{ message: 'Routing service unavailable (HTTP 502)' },
|
|
);
|
|
});
|
|
|
|
test('an HTML 502 gateway response tells voice the route service is unavailable', async () => {
|
|
const catalog = composeCatalog({
|
|
tools: coreTools,
|
|
services: {
|
|
routing: createRouteService({
|
|
fetchImpl: async () =>
|
|
new Response('<html>Bad Gateway</html>', {
|
|
status: 502,
|
|
headers: { 'content-type': 'text/html' },
|
|
}),
|
|
}),
|
|
places,
|
|
},
|
|
});
|
|
const server = createMcpServer({ catalog, name: 'test', version: '1.0.0' });
|
|
const { result } = await server.handle({
|
|
jsonrpc: '2.0',
|
|
id: 1,
|
|
method: 'tools/call',
|
|
params: {
|
|
name: 'plan_route',
|
|
arguments: { from: { place: 'Austin' }, to: { place: 'Dallas' } },
|
|
},
|
|
});
|
|
assert.equal(result.isError, true);
|
|
assert.equal(result.structuredContent.error, 'unavailable');
|
|
assert.equal(
|
|
result.content[0].text,
|
|
'Routing service unavailable (HTTP 502)',
|
|
);
|
|
});
|
|
|
|
test('place answers say when the search limits may have left places out', async () => {
|
|
const five = Array.from({ length: 5 }, (_, index) =>
|
|
place(`p${index}`, 30.27, -97.74),
|
|
);
|
|
const catalog = composeCatalog({
|
|
tools: coreTools,
|
|
services: {
|
|
placeSearch: placeSearch({ configured: true, places: five }),
|
|
places,
|
|
},
|
|
});
|
|
const capped = await catalog.call('search_places', {
|
|
query: 'coffee',
|
|
area: { place: 'Austin' },
|
|
limit: 100,
|
|
});
|
|
assert.equal(capped.data.may_have_more, true);
|
|
assert.match(capped.summary, /the search returns at most 5 matches\)\.$/);
|
|
const wide = await catalog.call('search_places', {
|
|
query: 'coffee',
|
|
area: { lat: 30.27, lon: -97.74, radius_km: 200 },
|
|
});
|
|
assert.equal(wide.data.searched_radius_km, 50);
|
|
assert.match(wide.summary, /searched within 50 km of the center/);
|
|
});
|