parseapi-mcp 1.9.6 → 1.10.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +29 -2
- package/dist/{chunk-GBHQZNH4.js → chunk-PID2V4GM.js} +253 -75
- package/dist/http.js +1 -1
- package/dist/registry.js +1 -1
- package/dist/stdio.js +1 -1
- package/package.json +2 -2
package/README.md
CHANGED
|
@@ -57,7 +57,7 @@ MCP packages older than 1.0.0 keep their existing behavior and use the team's de
|
|
|
57
57
|
|
|
58
58
|
Full mode provides 68 local lookup tools and 67 hosted lookup tools, plus `discover` for local metadata and `preflight` for authenticated task estimates. `ip_self` is local only. `time` returns current local time and Unix seconds. It accepts a timezone or coordinates and defaults to UTC when both are omitted. `date` parses the supplied date, or returns today in UTC when omitted. Existing `timezone` calls remain supported with their original arguments. Every lookup returns the JSON the API serves.
|
|
59
59
|
|
|
60
|
-
Tools follow the lookup names: `country_states`, `city_search`, `postal_nearby`, `address`, `address_search`, `company`, `company_id`, `company_search`, `company_coverage`, `email`, `vat`, `bank`, `bank_us_ach`, `bank_requirements`, `card`, `provider`, `
|
|
60
|
+
Tools follow the lookup names: `country_states`, `city_search`, `postal_nearby`, `address`, `address_search`, `company`, `company_id`, `company_search`, `company_coverage`, `email`, `vat`, `bank`, `bank_us_ach`, `bank_requirements`, `card`, `provider`, `industry`, `industry_search`, `tariff`, `dns`, `asn`, `mac`, `currency_rate`, and the rest. Text searches take `query`. Company directory search supports one name/domain/ticker/identifier selector or country/exact-SIC discovery filters.
|
|
61
61
|
|
|
62
62
|
The existing `naics` and `naics_search` tools remain available as compatibility names for Industry.
|
|
63
63
|
|
|
@@ -250,7 +250,6 @@ Bank tools send original IBAN, routing and account strings in POST JSON bodies,
|
|
|
250
250
|
|
|
251
251
|
When US ACH returns a bank name, MCP includes a separate [routing reference attribution](https://parseapi.com/legal/attribution#routing-numbers) notice alongside the unchanged JSON result.
|
|
252
252
|
|
|
253
|
-
Vehicle lookups use `vin` as the input and response field. The `vin` tool remains available for compatibility.
|
|
254
253
|
|
|
255
254
|
## Emoji catalog additions
|
|
256
255
|
|
|
@@ -279,3 +278,31 @@ A device's emoji font remains the ordinary display.
|
|
|
279
278
|
|
|
280
279
|
These additions are a local release candidate until the matching SDK and
|
|
281
280
|
backend are published. Existing lookup and search contracts are preserved.
|
|
281
|
+
|
|
282
|
+
|
|
283
|
+
## Canonical City operations
|
|
284
|
+
|
|
285
|
+
Classic lookup, search, nearest and named-nearby methods retain their default envelopes and required-field models. Browse and coordinate-nearby use canonical lists: `object`, `data` and nullable `next_cursor` (camelCase properties in Swift/Kotlin). Keep all query options unchanged when continuing a page; no client fetches pages automatically.
|
|
286
|
+
|
|
287
|
+
```json
|
|
288
|
+
{"operation":"city_search","arguments":{"query":"Viena","format":"list","match":"fuzzy","max_distance":1}}
|
|
289
|
+
```
|
|
290
|
+
|
|
291
|
+
Select `format=resource` for one City or `format=list` for a collection. Country inclusion/exclusion sets, timezone sets, inclusive population and meter-elevation bounds, stored-center `bbox` and signed multi-key sorting are available for collections. Unknown numeric facts do not match range filters.
|
|
292
|
+
|
|
293
|
+
Search defaults to prefix matching. Exact and fuzzy matching are explicit; fuzzy accepts maximum edit distance 1 or 2 and returns `match` evidence (`type`, `source`, `value`, `language`, `edit_distance`). Review a fuzzy choice before storing its ID.
|
|
294
|
+
|
|
295
|
+
Reviewed children, ancestors and siblings use canonical lists with partial relationship coverage. Empty data does not prove there are no geographic relatives. Children/siblings accept page controls; ancestors do not. Distance reports great-circle kilometers and miles between stored centers: zero is known zero, null is unknown, and it does not imply travel time or containment.
|
|
296
|
+
|
|
297
|
+
Strict `ambiguity=error` can return HTTP 409 `ambiguous_city` with up to two safe candidate identities. The existing error constructor and unrelated error metadata are preserved; candidates are retained only for that status/code and never contain Deep. GeoJSON is available through HTTP; these typed City list methods do not return GeoJSON.
|
|
298
|
+
|
|
299
|
+
|
|
300
|
+
|
|
301
|
+
|
|
302
|
+
|
|
303
|
+
Coverage by country and available fields is described at https://parseapi.com/city#coverage.
|
|
304
|
+
|
|
305
|
+
`romanized=true` requests reviewed official name forms as `name_romanized` and `romanization_language` (camelCase in Swift/Kotlin). Current reviewed forms cover 20 Japanese whole-city aliases in ja-Latn. Missing or conflicting forms stay null; ASCII folding is not substituted for an official form.
|
|
306
|
+
|
|
307
|
+
|
|
308
|
+
Conditional `If-None-Match` reads and GeoJSON currently use HTTP directly. A matching City ETag returns 304 without a body; ordinary billing and rate limits apply. These JSON client methods do not supply conditional-cache handling.
|
|
@@ -10,7 +10,7 @@ import { ParseAPIError } from "@parseapi/sdk";
|
|
|
10
10
|
function ok(data) {
|
|
11
11
|
return { content: [{ type: "text", text: JSON.stringify(data) }] };
|
|
12
12
|
}
|
|
13
|
-
function errorJson(code, message, docs, requestId, retryAfter) {
|
|
13
|
+
function errorJson(code, message, docs, requestId, retryAfter, candidates) {
|
|
14
14
|
return {
|
|
15
15
|
isError: true,
|
|
16
16
|
content: [{ type: "text", text: JSON.stringify({
|
|
@@ -18,13 +18,14 @@ function errorJson(code, message, docs, requestId, retryAfter) {
|
|
|
18
18
|
message,
|
|
19
19
|
docs,
|
|
20
20
|
request_id: requestId,
|
|
21
|
-
...retryAfter == null ? {} : { retry_after: retryAfter }
|
|
21
|
+
...retryAfter == null ? {} : { retry_after: retryAfter },
|
|
22
|
+
...candidates === void 0 ? {} : { candidates }
|
|
22
23
|
}) }]
|
|
23
24
|
};
|
|
24
25
|
}
|
|
25
26
|
function toErrorResult(err) {
|
|
26
27
|
if (err instanceof ParseAPIError) {
|
|
27
|
-
return errorJson(err.code, err.message, err.docs, err.requestId, err.retryAfter);
|
|
28
|
+
return errorJson(err.code, err.message, err.docs, err.requestId, err.retryAfter, err.status === 409 && err.code === "ambiguous_city" ? err.candidates : void 0);
|
|
28
29
|
}
|
|
29
30
|
const message = err instanceof Error ? err.message : String(err);
|
|
30
31
|
return errorJson("network_error", message, null, null);
|
|
@@ -435,18 +436,14 @@ var agent_catalog_default = {
|
|
|
435
436
|
],
|
|
436
437
|
freshness: {
|
|
437
438
|
mode: "maintained_reference",
|
|
438
|
-
population_period_field: "deep.population_period",
|
|
439
439
|
uniform_refresh_interval_seconds: null,
|
|
440
440
|
actual_age_seconds: null,
|
|
441
|
-
actual_age_status: "not_exposed; population
|
|
441
|
+
actual_age_status: "not_exposed; population observation evidence remains internal"
|
|
442
442
|
},
|
|
443
443
|
uncertainty: {
|
|
444
444
|
name_local: {
|
|
445
445
|
null: "Native name unavailable or identical to the original name before display translation"
|
|
446
446
|
},
|
|
447
|
-
"deep.population_period": {
|
|
448
|
-
null: "Observation period is unknown; never infer it from an import date"
|
|
449
|
-
},
|
|
450
447
|
"deep.water_area": {
|
|
451
448
|
null: "Unknown or inconsistent with the archived total",
|
|
452
449
|
zero: "Reported zero water area"
|
|
@@ -1373,6 +1370,118 @@ var agent_catalog_default = {
|
|
|
1373
1370
|
help: "https://api.parseapi.com/version/2.0.0/emoji/help",
|
|
1374
1371
|
guide: "https://parseapi.com/docs/emoji"
|
|
1375
1372
|
}
|
|
1373
|
+
},
|
|
1374
|
+
city: {
|
|
1375
|
+
operation: "city",
|
|
1376
|
+
endpoint: "GET /city/{name}",
|
|
1377
|
+
endpoints: {
|
|
1378
|
+
resource: "GET /city/id/{id}?format=resource",
|
|
1379
|
+
typeahead: "GET /city?q={query}",
|
|
1380
|
+
browse: "GET /city?browse=true&format=list",
|
|
1381
|
+
spelling: "GET /city/search?q={query}&match={exact|prefix|fuzzy}",
|
|
1382
|
+
nearby_coordinates: "GET /city?lat={lat}&lon={lon}&nearby=true&format=list",
|
|
1383
|
+
children: "GET /city/id/{id}/children",
|
|
1384
|
+
ancestors: "GET /city/id/{id}/ancestors",
|
|
1385
|
+
siblings: "GET /city/id/{id}/siblings",
|
|
1386
|
+
distance: "GET /city/id/{id}/distance/{other}"
|
|
1387
|
+
},
|
|
1388
|
+
determines: [
|
|
1389
|
+
"Covered place identity, native/display names, source place type, geography and timezone where available",
|
|
1390
|
+
"Optional reviewed grain, immediate parent and partial direct place relationships",
|
|
1391
|
+
"Filtered paged City collections; optional paid Deep population, observation date, elevation and area",
|
|
1392
|
+
"Great-circle distance between recorded centers; optional admitted official romanization"
|
|
1393
|
+
],
|
|
1394
|
+
does_not_determine: [
|
|
1395
|
+
"Complete worldwide place or field coverage",
|
|
1396
|
+
"Road distance, routing or travel time",
|
|
1397
|
+
"Official romanization from ASCII folding",
|
|
1398
|
+
"A fresh upstream acquisition on every request",
|
|
1399
|
+
"City execution through /task or /preflight; those admission policies are separate"
|
|
1400
|
+
],
|
|
1401
|
+
required_context: [
|
|
1402
|
+
"Store the own city_ ID from a selected response; do not substitute an upstream identifier or a display name",
|
|
1403
|
+
"Keep country and state codes together; state names are not valid state filters",
|
|
1404
|
+
"Choose grain=municipality when selecting a reviewed whole municipality; type retains source terminology",
|
|
1405
|
+
"Use ambiguity=error for exact selection that requires a caller choice; 409 candidates are bounded public identities",
|
|
1406
|
+
"Keep all filters, limit, language and shape options unchanged when reusing next_cursor"
|
|
1407
|
+
],
|
|
1408
|
+
response: {
|
|
1409
|
+
resource: "format=resource: object=city and the complete ordinary City fields, including own id",
|
|
1410
|
+
collection: "format=list: object=list, data and next_cursor; keep request filters unchanged for continuation",
|
|
1411
|
+
legacy: "Default lookup, typeahead and named-nearby envelopes remain compatible",
|
|
1412
|
+
geojson: "format=geojson: Feature or FeatureCollection; null geometry when coordinates are unavailable"
|
|
1413
|
+
},
|
|
1414
|
+
freshness: {
|
|
1415
|
+
mode: "maintained_source_reference",
|
|
1416
|
+
actual_age_seconds: null,
|
|
1417
|
+
actual_age_status: "Fact observation dates where available; an import date is not an observation date",
|
|
1418
|
+
notes: "Population dates and place boundaries may differ between records. Coverage and limits are documented on the City lander and reference."
|
|
1419
|
+
},
|
|
1420
|
+
uncertainty: {
|
|
1421
|
+
null: "Unsupported, missing or conflicting facts remain null. Null population is not zero. Unknown grain and parent remain null.",
|
|
1422
|
+
coverage: "Partial curated reference. A catalog or index must pass its activation gate; readiness503 is not an empty match.",
|
|
1423
|
+
romanization: "romanized=true returns admitted official aliases only; missing or conflicting aliases return null.",
|
|
1424
|
+
relationships: "coverage=partial; no parent or relation is inferred from a matching name or distance.",
|
|
1425
|
+
distance: "method=great_circle; known zero is preserved, unknown coordinates yield null."
|
|
1426
|
+
},
|
|
1427
|
+
errors: {
|
|
1428
|
+
"400": "Invalid controls or cursor from another query/catalog; restart pagination when the edition changes",
|
|
1429
|
+
"409": "ambiguous_city under ambiguity=error; bounded safe candidates without Deep",
|
|
1430
|
+
"404": "City ID or name is not present in the serving catalog",
|
|
1431
|
+
"503": "Required catalog or admitted spelling index unavailable"
|
|
1432
|
+
},
|
|
1433
|
+
billing: {
|
|
1434
|
+
pooled_requests_per_success: 1,
|
|
1435
|
+
metered: null,
|
|
1436
|
+
deep_extra_units: 0,
|
|
1437
|
+
monetary_quote: null,
|
|
1438
|
+
account_state: "unknown; access, allowance and accepted account terms still apply",
|
|
1439
|
+
conditional_reads: "A 304 response does not waive ordinary request billing"
|
|
1440
|
+
},
|
|
1441
|
+
access: {
|
|
1442
|
+
api_key_required: true,
|
|
1443
|
+
key_types: [
|
|
1444
|
+
"secret",
|
|
1445
|
+
"public",
|
|
1446
|
+
"app"
|
|
1447
|
+
],
|
|
1448
|
+
key_fences: {
|
|
1449
|
+
public: "Allowed browser origin required",
|
|
1450
|
+
app: "Allowed X-App-Id required"
|
|
1451
|
+
},
|
|
1452
|
+
effective_access: null,
|
|
1453
|
+
effective_access_status: "not_checked; key fences, account access and quotas still apply"
|
|
1454
|
+
},
|
|
1455
|
+
retry: {
|
|
1456
|
+
client: "javascript_sdk_and_mcp",
|
|
1457
|
+
default_retries: 2,
|
|
1458
|
+
retry_http_statuses: [
|
|
1459
|
+
429,
|
|
1460
|
+
500,
|
|
1461
|
+
502,
|
|
1462
|
+
503,
|
|
1463
|
+
504
|
|
1464
|
+
],
|
|
1465
|
+
retry_network_errors: true,
|
|
1466
|
+
successful_unknown_retried: false,
|
|
1467
|
+
guidance: "Do not retry a409 automatically. Select a bounded candidate. Correct invalid filters and restart rejected cursors. Respect Retry-After; empty matches are not an outage."
|
|
1468
|
+
},
|
|
1469
|
+
privacy: {
|
|
1470
|
+
public_identity: "Own City IDs only",
|
|
1471
|
+
not_exposed: [
|
|
1472
|
+
"upstream identifiers",
|
|
1473
|
+
"source record keys",
|
|
1474
|
+
"private evidence URLs",
|
|
1475
|
+
"source hashes",
|
|
1476
|
+
"complete dataset exports"
|
|
1477
|
+
]
|
|
1478
|
+
},
|
|
1479
|
+
docs: {
|
|
1480
|
+
help: "https://api.parseapi.com/version/2.0.0/city/help",
|
|
1481
|
+
guide: "https://parseapi.com/docs/city",
|
|
1482
|
+
selection: "https://parseapi.com/docs/city#choose-a-city",
|
|
1483
|
+
continuity: "https://parseapi.com/docs/city#stable-ids"
|
|
1484
|
+
}
|
|
1376
1485
|
}
|
|
1377
1486
|
}
|
|
1378
1487
|
};
|
|
@@ -1548,7 +1657,7 @@ function registerTasks(server, client, transport) {
|
|
|
1548
1657
|
// package.json
|
|
1549
1658
|
var package_default = {
|
|
1550
1659
|
name: "parseapi-mcp",
|
|
1551
|
-
version: "1.
|
|
1660
|
+
version: "1.10.1",
|
|
1552
1661
|
mcpName: "com.parseapi/mcp",
|
|
1553
1662
|
description: "Official ParseAPI MCP server. Look up places, addresses, company numbers, email, phone, weather, dates and more.",
|
|
1554
1663
|
keywords: [
|
|
@@ -1598,7 +1707,7 @@ var package_default = {
|
|
|
1598
1707
|
dependencies: {
|
|
1599
1708
|
"@modelcontextprotocol/node": "^2.0.0",
|
|
1600
1709
|
"@modelcontextprotocol/server": "^2.0.0",
|
|
1601
|
-
"@parseapi/sdk": "1.
|
|
1710
|
+
"@parseapi/sdk": "^1.11.1",
|
|
1602
1711
|
zod: "^4.0.0"
|
|
1603
1712
|
},
|
|
1604
1713
|
devDependencies: {
|
|
@@ -1633,7 +1742,6 @@ var titleWords = {
|
|
|
1633
1742
|
iban: "IBAN",
|
|
1634
1743
|
npi: "NPI",
|
|
1635
1744
|
naics: "NAICS",
|
|
1636
|
-
vin: "VIN",
|
|
1637
1745
|
bin: "BIN",
|
|
1638
1746
|
us: "US",
|
|
1639
1747
|
ach: "ACH",
|
|
@@ -1642,42 +1750,52 @@ var titleWords = {
|
|
|
1642
1750
|
mac: "MAC",
|
|
1643
1751
|
useragent: "User Agent"
|
|
1644
1752
|
};
|
|
1645
|
-
var
|
|
1646
|
-
"
|
|
1647
|
-
"
|
|
1648
|
-
"
|
|
1649
|
-
|
|
1650
|
-
|
|
1651
|
-
|
|
1652
|
-
|
|
1653
|
-
|
|
1654
|
-
|
|
1655
|
-
|
|
1656
|
-
|
|
1657
|
-
|
|
1658
|
-
"
|
|
1659
|
-
"
|
|
1660
|
-
"
|
|
1661
|
-
"
|
|
1662
|
-
"
|
|
1663
|
-
"
|
|
1664
|
-
"
|
|
1665
|
-
"
|
|
1666
|
-
"
|
|
1667
|
-
"
|
|
1668
|
-
"
|
|
1669
|
-
|
|
1670
|
-
|
|
1671
|
-
|
|
1672
|
-
|
|
1673
|
-
|
|
1674
|
-
|
|
1675
|
-
|
|
1676
|
-
|
|
1677
|
-
|
|
1678
|
-
|
|
1679
|
-
|
|
1680
|
-
|
|
1753
|
+
var cityScope = {
|
|
1754
|
+
type: z4.string().min(1).max(60).optional().describe("Stored place type, such as city or ward; filters eligible places without inferring legal status."),
|
|
1755
|
+
grain: z4.enum(["municipality", "subdivision", "locality", "metropolitan_area"]).optional().describe("Reviewed entity grain. Unreviewed places do not match; requires City foundation readiness."),
|
|
1756
|
+
hierarchy: z4.boolean().optional().describe("Include reviewed grain and immediate parent summary, or null when unknown. Requires foundation readiness; otherwise 503.")
|
|
1757
|
+
};
|
|
1758
|
+
var cityAliases = z4.boolean().optional().describe("Match reviewed normalized aliases. Compatibility characters, case and whitespace normalize; native marks and accents remain. No spelling guesses. Requires foundation readiness.");
|
|
1759
|
+
var cityAmbiguity = z4.literal("error").optional().describe("Reject an exact name or nearby anchor matching multiple eligible places with HTTP 409 ambiguous_city and bounded candidate identities. Add filters or choose a stable id from city_search.");
|
|
1760
|
+
var cityRomanized = z4.boolean().optional().describe("Include a reviewed official romanized name and its language. No ASCII-folding fallback; missing or conflicting forms are null.");
|
|
1761
|
+
var cityResourceResponse = { romanized: cityRomanized, format: z4.literal("resource").optional().describe("Opt into object:city without changing classic responses.") };
|
|
1762
|
+
var cityListResponse = { romanized: cityRomanized, format: z4.literal("list").optional().describe("Opt into object:list, data and next_cursor. A null cursor ends the collection; keep the same options on continuation.") };
|
|
1763
|
+
var citySort = (terms) => z4.string().min(1).max(100).regex(new RegExp(`^[+-]?(${terms.join("|")})(,[+-]?(${terms.join("|")}))*$`)).optional().describe("Comma-separated sort terms. Prefix a term with + or - for its direction. Stable ids break ties; unknown values sort last.");
|
|
1764
|
+
var cityCodeList = z4.union([z4.string().min(2).max(149), z4.array(z4.string().regex(/^[a-zA-Z]{2}$/)).min(1).max(50)]).optional();
|
|
1765
|
+
var cityCollectionFilters = {
|
|
1766
|
+
min_population: z4.number().int().min(0).max(Number.MAX_SAFE_INTEGER).optional().describe("Minimum stored population. Unknown values do not match; the count may be undated."),
|
|
1767
|
+
max_population: z4.number().int().min(0).max(Number.MAX_SAFE_INTEGER).optional().describe("Maximum stored population. Unknown values do not match; the count may be undated."),
|
|
1768
|
+
min_elevation: z4.number().finite().optional().describe("Minimum stored elevation in meters. Unknown values do not match."),
|
|
1769
|
+
max_elevation: z4.number().finite().optional().describe("Maximum stored elevation in meters. Unknown values do not match."),
|
|
1770
|
+
countries: cityCodeList.describe("Include ISO2 countries, as CSV or an array. Intersects with a single country filter; on named nearby, country selects the anchor."),
|
|
1771
|
+
exclude_countries: cityCodeList.describe("Exclude ISO2 countries, as CSV or an array."),
|
|
1772
|
+
timezones: z4.union([z4.string().min(1).max(5049), z4.array(z4.string().min(1).max(100)).min(1).max(50)]).optional().describe("Include exact IANA timezones, as CSV or an array. Intersects with a single timezone filter."),
|
|
1773
|
+
timezone: z4.string().optional().describe("Exact IANA timezone filter, e.g. Europe/Vienna."),
|
|
1774
|
+
bbox: z4.string().optional().describe("Stored-center bounds as west,south,east,north in degrees. West greater than east crosses the date line."),
|
|
1775
|
+
order: z4.enum(["asc", "desc"]).optional().describe("Sort direction; default asc except population defaults to desc. Stable ids break ties."),
|
|
1776
|
+
cursor: z4.string().optional().describe("Opaque continuation cursor. Reuse with exactly the same query, filters, limit, display language, Deep, hierarchy and origin.")
|
|
1777
|
+
};
|
|
1778
|
+
var cityPage = z4.boolean().optional().describe("Opt into next_cursor on search or named-nearby collections. A cursor also enables paging.");
|
|
1779
|
+
function cityCollectionArguments(args) {
|
|
1780
|
+
return {
|
|
1781
|
+
minPopulation: args.min_population,
|
|
1782
|
+
maxPopulation: args.max_population,
|
|
1783
|
+
minElevation: args.min_elevation,
|
|
1784
|
+
maxElevation: args.max_elevation,
|
|
1785
|
+
countries: args.countries,
|
|
1786
|
+
excludeCountries: args.exclude_countries,
|
|
1787
|
+
timezones: args.timezones,
|
|
1788
|
+
timezone: args.timezone,
|
|
1789
|
+
bbox: args.bbox,
|
|
1790
|
+
sort: args.sort,
|
|
1791
|
+
order: args.order,
|
|
1792
|
+
page: args.page || void 0,
|
|
1793
|
+
cursor: args.cursor,
|
|
1794
|
+
format: args.format,
|
|
1795
|
+
romanized: args.romanized || void 0
|
|
1796
|
+
};
|
|
1797
|
+
}
|
|
1798
|
+
var languageTools = /* @__PURE__ */ new Set(["ip", "ip_self", "asn", "company", "npi", "provider", "continent", "continent_countries", "bloc_countries", "country", "country_states", "state", "state_districts", "district", "city", "city_id", "city_search", "city_nearest", "city_nearby", "postal", "postal_nearby", "postal_distance", "currency", "language", "date", "time", "timezone", "measure_units", "emoji", "emoji_search", "emoji_browse", "emoji_parse", "emoji_catalog", "point", "city_list", "city_nearby_coordinates", "city_children", "city_ancestors", "city_siblings"]);
|
|
1681
1799
|
var displayLanguage = z4.string().min(2).max(64).optional().describe("Optional display language, such as fr or zh-Hant. IDs, numeric values and input parsing stay unchanged.");
|
|
1682
1800
|
var emojiFilters = {
|
|
1683
1801
|
limit: z4.number().int().min(1).max(50).optional().describe("Maximum results per page."),
|
|
@@ -1814,7 +1932,7 @@ function buildServer(key, transport, options = {}) {
|
|
|
1814
1932
|
);
|
|
1815
1933
|
tool(
|
|
1816
1934
|
"country",
|
|
1817
|
-
"Country names, language codes, currency, calling code and timezones. Deep adds the country reference profile on paid plans, including population
|
|
1935
|
+
"Country names, language codes, currency, calling code and timezones. Deep adds the country reference profile on paid plans, including population, land/water area in km2, coastline in km, mean and extreme elevations in metres, tax and locale conventions. Unknown geography values stay null.",
|
|
1818
1936
|
{ code: iso2("country code"), deep: deep.describe("Include the complete detail bag on a paid plan.") },
|
|
1819
1937
|
(c, a, request) => c.country(a.code, { ...request, deep: a.deep })
|
|
1820
1938
|
);
|
|
@@ -1826,7 +1944,7 @@ function buildServer(key, transport, options = {}) {
|
|
|
1826
1944
|
);
|
|
1827
1945
|
tool(
|
|
1828
1946
|
"state",
|
|
1829
|
-
"Look up a state or province by code or name. Deep adds its demographic and tax profile on paid plans
|
|
1947
|
+
"Look up a state or province by code or name. Deep adds its demographic and tax profile on paid plans. Pass country to resolve a colliding code.",
|
|
1830
1948
|
{
|
|
1831
1949
|
code: z4.string().describe("State code or name, e.g. colorado, NC"),
|
|
1832
1950
|
country: countryOpt,
|
|
@@ -1836,17 +1954,17 @@ function buildServer(key, transport, options = {}) {
|
|
|
1836
1954
|
);
|
|
1837
1955
|
tool(
|
|
1838
1956
|
"state_districts",
|
|
1839
|
-
"List the districts, counties or departments of a state. Deep adds population
|
|
1957
|
+
"List the districts, counties or departments of a state. Deep adds population to each result on paid plans.",
|
|
1840
1958
|
{
|
|
1841
1959
|
code: z4.string().describe("State code or name, e.g. NC, colorado"),
|
|
1842
1960
|
country: countryOpt,
|
|
1843
|
-
deep: deep.describe("Include population
|
|
1961
|
+
deep: deep.describe("Include population in each district detail bag on a paid plan.")
|
|
1844
1962
|
},
|
|
1845
1963
|
(c, a, request) => c.state.districts(a.code, { ...request, deep: a.deep, country: a.country })
|
|
1846
1964
|
);
|
|
1847
1965
|
tool(
|
|
1848
1966
|
"district",
|
|
1849
|
-
"Look up a district, county or department by code or name. Deep adds area, population and seat on paid plans. Pass state to resolve a colliding name.
|
|
1967
|
+
"Look up a district, county or department by code or name. Deep adds area, population and seat on paid plans. Pass state to resolve a colliding name. Paid deep property_tax contains annual_median, currency and period: median annual tax payable on owner-occupied homes in the area, adjusted to the final year of that period. It is not a rate or property bill. Unsupported, missing and censored estimates are null.",
|
|
1850
1968
|
{
|
|
1851
1969
|
code: z4.string().describe("District code or name, e.g. 37081, guilford county"),
|
|
1852
1970
|
country: countryOpt,
|
|
@@ -1857,38 +1975,50 @@ function buildServer(key, transport, options = {}) {
|
|
|
1857
1975
|
);
|
|
1858
1976
|
tool(
|
|
1859
1977
|
"city",
|
|
1860
|
-
"Resolve a city name to coordinates, timezone and administrative context. Deep adds demographic and geographic detail on paid plans. Pass country or state for name ties.
|
|
1978
|
+
"Resolve a city name to coordinates, timezone and administrative context. Deep adds demographic and geographic detail on paid plans. Pass country or state for name ties.",
|
|
1861
1979
|
{
|
|
1862
1980
|
name: z4.string().describe("City name, e.g. charlotte"),
|
|
1863
1981
|
country: countryOpt,
|
|
1864
1982
|
state: z4.string().optional().describe("State code to disambiguate, e.g. NC"),
|
|
1983
|
+
...cityScope,
|
|
1984
|
+
...cityResourceResponse,
|
|
1985
|
+
aliases: cityAliases,
|
|
1986
|
+
ambiguity: cityAmbiguity,
|
|
1865
1987
|
deep: deep.describe("Include the complete detail bag on a paid plan.")
|
|
1866
1988
|
},
|
|
1867
|
-
(c, a, request) => c.city(a.name, { ...request, deep: a.deep, country: a.country, state: a.state })
|
|
1989
|
+
(c, a, request) => c.city(a.name, { ...request, deep: a.deep, country: a.country, state: a.state, type: a.type, grain: a.grain, aliases: a.aliases || void 0, hierarchy: a.hierarchy || void 0, ambiguity: a.ambiguity, format: a.format, romanized: a.romanized || void 0 })
|
|
1868
1990
|
);
|
|
1869
1991
|
tool(
|
|
1870
1992
|
"city_id",
|
|
1871
1993
|
"Resolve a stable city id. Deep adds the city profile on paid plans.",
|
|
1872
|
-
{ id: z4.string().describe("Stable city id, e.g. city_mb8mbqrkz8zb"), deep: deep.describe("Include the complete detail bag on a paid plan.") },
|
|
1873
|
-
(c, a, request) => c.city.id(a.id, { ...request, deep: a.deep })
|
|
1994
|
+
{ id: z4.string().describe("Stable city id, e.g. city_mb8mbqrkz8zb"), ...cityResourceResponse, hierarchy: cityScope.hierarchy, deep: deep.describe("Include the complete detail bag on a paid plan.") },
|
|
1995
|
+
(c, a, request) => c.city.id(a.id, { ...request, deep: a.deep, hierarchy: a.hierarchy || void 0, format: a.format, romanized: a.romanized || void 0 })
|
|
1874
1996
|
);
|
|
1875
1997
|
tool(
|
|
1876
1998
|
"city_search",
|
|
1877
|
-
"Search city names. Deep adds the profile inside each returned city on paid plans.",
|
|
1999
|
+
"Search city names. Explicit match uses the spelling search route; numeric/map/timezone/sort filters apply to default prefix search only. Deep adds the profile inside each returned city on paid plans.",
|
|
1878
2000
|
{
|
|
1879
|
-
query: z4.string().describe("
|
|
2001
|
+
query: z4.string().describe("City name query, e.g. char"),
|
|
2002
|
+
match: z4.enum(["exact", "prefix", "fuzzy"]).optional().describe("Explicit matching mode; default prefix. Fuzzy results carry suggestion evidence."),
|
|
2003
|
+
max_distance: z4.union([z4.literal(1), z4.literal(2)]).optional().describe("Maximum edit distance for fuzzy matching."),
|
|
1880
2004
|
country: countryOpt,
|
|
1881
2005
|
state: z4.string().optional().describe("State code filter"),
|
|
2006
|
+
...cityScope,
|
|
2007
|
+
aliases: cityAliases,
|
|
2008
|
+
...cityCollectionFilters,
|
|
2009
|
+
...cityListResponse,
|
|
2010
|
+
sort: citySort(["relevance", "name", "population", "country", "elevation"]),
|
|
2011
|
+
page: cityPage,
|
|
1882
2012
|
limit: z4.number().int().min(1).max(50).optional().describe("Max results"),
|
|
1883
2013
|
deep: deep.describe("Include the complete detail bag on a paid plan.")
|
|
1884
2014
|
},
|
|
1885
|
-
(c, a, request) => c.city.search(a.query, { ...request, deep: a.deep, country: a.country, state: a.state, limit: a.limit })
|
|
2015
|
+
(c, a, request) => c.city.search(a.query, { ...request, deep: a.deep, country: a.country, state: a.state, limit: a.limit, match: a.match, maxDistance: a.max_distance, type: a.type, grain: a.grain, aliases: a.aliases || void 0, hierarchy: a.hierarchy || void 0, ...cityCollectionArguments(a) })
|
|
1886
2016
|
);
|
|
1887
2017
|
tool(
|
|
1888
2018
|
"city_nearest",
|
|
1889
|
-
"Find the nearest city with distance. Deep adds the
|
|
1890
|
-
{ lat, lon, deep },
|
|
1891
|
-
(c, a, request) => c.city.nearest(a.lat, a.lon, { ...request, deep: a.deep })
|
|
2019
|
+
"Find the nearest eligible stored city center within 2,000 km, with distance. Country/state/type/grain constrain candidates; this does not determine which municipality contains the point. Deep adds the paid profile and reviewed observation date/basis when known.",
|
|
2020
|
+
{ lat, lon, country: countryOpt, state: z4.string().optional().describe("State code filter"), ...cityScope, ...cityResourceResponse, deep },
|
|
2021
|
+
(c, a, request) => c.city.nearest(a.lat, a.lon, { ...request, deep: a.deep, country: a.country, state: a.state, type: a.type, grain: a.grain, hierarchy: a.hierarchy || void 0, format: a.format, romanized: a.romanized || void 0 })
|
|
1892
2022
|
);
|
|
1893
2023
|
tool(
|
|
1894
2024
|
"city_nearby",
|
|
@@ -1897,6 +2027,13 @@ function buildServer(key, transport, options = {}) {
|
|
|
1897
2027
|
name: z4.string().describe("Anchor city name, e.g. denver"),
|
|
1898
2028
|
country: countryOpt,
|
|
1899
2029
|
state: z4.string().optional().describe("State code to disambiguate the anchor"),
|
|
2030
|
+
...cityScope,
|
|
2031
|
+
aliases: cityAliases,
|
|
2032
|
+
ambiguity: cityAmbiguity,
|
|
2033
|
+
...cityCollectionFilters,
|
|
2034
|
+
...cityListResponse,
|
|
2035
|
+
sort: citySort(["distance", "name", "population", "country", "elevation"]),
|
|
2036
|
+
page: cityPage,
|
|
1900
2037
|
radius: z4.number().positive().optional().describe("Search radius, default 40 km"),
|
|
1901
2038
|
unit: z4.enum(["km", "mi"]).optional().describe("Radius unit, default km"),
|
|
1902
2039
|
limit: z4.number().int().min(1).max(50).optional().describe("Max results, default 10"),
|
|
@@ -1904,17 +2041,70 @@ function buildServer(key, transport, options = {}) {
|
|
|
1904
2041
|
},
|
|
1905
2042
|
(c, a, request) => c.city.nearby(a.name, {
|
|
1906
2043
|
...request,
|
|
2044
|
+
...cityCollectionArguments(a),
|
|
1907
2045
|
deep: a.deep,
|
|
1908
2046
|
country: a.country,
|
|
1909
2047
|
state: a.state,
|
|
2048
|
+
type: a.type,
|
|
2049
|
+
grain: a.grain,
|
|
2050
|
+
aliases: a.aliases || void 0,
|
|
2051
|
+
hierarchy: a.hierarchy || void 0,
|
|
2052
|
+
ambiguity: a.ambiguity,
|
|
1910
2053
|
radius: a.radius,
|
|
1911
2054
|
unit: a.unit,
|
|
1912
2055
|
limit: a.limit
|
|
1913
2056
|
})
|
|
1914
2057
|
);
|
|
2058
|
+
tool(
|
|
2059
|
+
"city_list",
|
|
2060
|
+
"Browse the stored City catalog with filters, stable sorting and opaque cursor paging. Coverage remains curated, not worldwide. Deep adds the paid profile within each record.",
|
|
2061
|
+
{
|
|
2062
|
+
country: countryOpt,
|
|
2063
|
+
state: z4.string().optional().describe("State code filter"),
|
|
2064
|
+
...cityScope,
|
|
2065
|
+
...cityCollectionFilters,
|
|
2066
|
+
...cityListResponse,
|
|
2067
|
+
sort: citySort(["name", "population", "country", "elevation"]),
|
|
2068
|
+
limit: z4.number().int().min(1).max(50).optional().describe("Max results per page"),
|
|
2069
|
+
deep: deep.describe("Include the complete detail bag on a paid plan.")
|
|
2070
|
+
},
|
|
2071
|
+
(c, a, request) => c.city.list({ ...request, ...cityCollectionArguments(a), country: a.country, state: a.state, type: a.type, grain: a.grain, hierarchy: a.hierarchy || void 0, limit: a.limit, deep: a.deep })
|
|
2072
|
+
);
|
|
2073
|
+
tool(
|
|
2074
|
+
"city_nearby_coordinates",
|
|
2075
|
+
"List stored city centers near arbitrary coordinates, with radius, collection filters and cursor paging. The point and distances do not infer municipality containment. Deep adds the paid profile within each record.",
|
|
2076
|
+
{
|
|
2077
|
+
lat,
|
|
2078
|
+
lon,
|
|
2079
|
+
country: countryOpt,
|
|
2080
|
+
state: z4.string().optional().describe("State code filter for returned neighbors"),
|
|
2081
|
+
...cityScope,
|
|
2082
|
+
...cityCollectionFilters,
|
|
2083
|
+
...cityListResponse,
|
|
2084
|
+
radius: z4.number().positive().optional().describe("Search radius, default 40 km"),
|
|
2085
|
+
unit: z4.enum(["km", "mi"]).optional().describe("Radius unit, default km"),
|
|
2086
|
+
sort: citySort(["distance", "name", "population", "country", "elevation"]),
|
|
2087
|
+
limit: z4.number().int().min(1).max(50).optional().describe("Max results per page"),
|
|
2088
|
+
deep: deep.describe("Include the complete detail bag on a paid plan.")
|
|
2089
|
+
},
|
|
2090
|
+
(c, a, request) => c.city.nearbyCoordinates(a.lat, a.lon, { ...request, ...cityCollectionArguments(a), country: a.country, state: a.state, type: a.type, grain: a.grain, hierarchy: a.hierarchy || void 0, radius: a.radius, unit: a.unit, limit: a.limit, deep: a.deep })
|
|
2091
|
+
);
|
|
2092
|
+
const cityRelationId = z4.string().regex(/^city_[23456789abcdefghjkmnpqrstuvwxyz]{12}$/).describe("Stable City id selected from a lookup or search.");
|
|
2093
|
+
const cityRelationOptions = {
|
|
2094
|
+
id: cityRelationId,
|
|
2095
|
+
romanized: cityRomanized,
|
|
2096
|
+
hierarchy: cityScope.hierarchy,
|
|
2097
|
+
deep,
|
|
2098
|
+
limit: z4.number().int().min(1).max(50).optional().describe("Maximum records per page."),
|
|
2099
|
+
cursor: cityCollectionFilters.cursor
|
|
2100
|
+
};
|
|
2101
|
+
tool("city_children", "List reviewed immediate children of a City id. Returns a canonical list with coverage:partial. It does not infer missing relationships.", cityRelationOptions, (c, a, request) => c.city.children(a.id, { ...request, romanized: a.romanized || void 0, limit: a.limit, cursor: a.cursor, hierarchy: a.hierarchy || void 0, deep: a.deep }));
|
|
2102
|
+
tool("city_ancestors", "Follow reviewed parents of a City id, immediate parent first. Returns a canonical list with coverage:partial; an empty list does not prove the city has no administrative parent.", { id: cityRelationId, romanized: cityRomanized, hierarchy: cityScope.hierarchy, deep }, (c, a, request) => c.city.ancestors(a.id, { ...request, romanized: a.romanized || void 0, hierarchy: a.hierarchy || void 0, deep: a.deep }));
|
|
2103
|
+
tool("city_siblings", "List reviewed places sharing the selected City id\u2019s immediate parent. Returns a canonical list with parent_id and coverage:partial.", cityRelationOptions, (c, a, request) => c.city.siblings(a.id, { ...request, romanized: a.romanized || void 0, limit: a.limit, cursor: a.cursor, hierarchy: a.hierarchy || void 0, deep: a.deep }));
|
|
2104
|
+
tool("city_distance", "Great-circle kilometers and miles between two stored City centers. Unknown coordinates return null; this is not travel distance or boundary containment.", { from: cityRelationId, to: cityRelationId }, (c, a, request) => c.city.distance(a.from, a.to, request));
|
|
1915
2105
|
tool(
|
|
1916
2106
|
"postal",
|
|
1917
|
-
"Resolve a postal code to its place, coordinates and timezone. Australian core localities lists suburb choices with city, state and state_name. Null or missing means unknown, and [] means no eligible choices in the reviewed reference. A single choice can coexist with city null, so do not infer a city or a user selection. These are geographic choices, not mailing-address verification. Deep adds area, population
|
|
2107
|
+
"Resolve a postal code to its place, coordinates and timezone. Australian core localities lists suburb choices with city, state and state_name. Null or missing means unknown, and [] means no eligible choices in the reviewed reference. A single choice can coexist with city null, so do not infer a city or a user selection. These are geographic choices, not mailing-address verification. Deep adds area, population, tax references, neighbors and metro associations on paid plans. property_tax is a nullable area statistic with annual_median, currency and period: median annual tax payable on owner-occupied homes, adjusted to the final year of the period. It is not a rate or property bill. Unsupported, missing and censored estimates are null. Tax rates are percentages and alternative geographic references, not additive.",
|
|
1918
2108
|
{
|
|
1919
2109
|
code: z4.string().describe("Postal or ZIP code, e.g. SW1A 1AA, 28202"),
|
|
1920
2110
|
country: countryOpt,
|
|
@@ -2229,18 +2419,6 @@ function buildServer(key, transport, options = {}) {
|
|
|
2229
2419
|
{ ua: z4.string().describe("The User-Agent string to parse"), deep },
|
|
2230
2420
|
(c, a, request) => c.useragent(a.ua, { ...request, deep: a.deep })
|
|
2231
2421
|
);
|
|
2232
|
-
tool(
|
|
2233
|
-
"vehicle",
|
|
2234
|
-
"Identify a vehicle by VIN: year, make, model, trim, body and vehicle type. Paid deep adds specifications, manufacturing detail and model-level recall campaigns. These do not establish whether this VIN needs a repair.",
|
|
2235
|
-
{ vin: z4.string().describe("The VIN as you have it. Spaces and punctuation fold out"), deep },
|
|
2236
|
-
(c, a, request) => c.vehicle(a.vin, { ...request, deep: a.deep })
|
|
2237
|
-
);
|
|
2238
|
-
tool(
|
|
2239
|
-
"vin",
|
|
2240
|
-
"Compatibility entry for vehicle. Decode a VIN to year, make, model, trim, body and vehicle type. Paid deep adds specifications, manufacturing detail and model-level recall campaigns.",
|
|
2241
|
-
{ vin: z4.string().describe("The VIN as you have it. Spaces and punctuation fold out"), deep },
|
|
2242
|
-
(c, a, request) => c.vin(a.vin, { ...request, deep: a.deep })
|
|
2243
|
-
);
|
|
2244
2422
|
tool(
|
|
2245
2423
|
"tariff",
|
|
2246
2424
|
"Look up a US tariff code, description, lineage, published base general rate, exact edition and answering date. Paid deep adds schedule columns, units and matched Chapter 99 measures. Origin is the country where goods originate, not the shipping country. Optional edition pins immutable source bytes. Optional date requires verified source coverage; edition without date returns date null and no effective rate. Default requests use today. deep.reason explains a null effective_rate, including incomplete_coverage; null never means zero. Matched measures are inspectable candidates, not complete duty or landed cost.",
|
package/dist/http.js
CHANGED
package/dist/registry.js
CHANGED
package/dist/stdio.js
CHANGED
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "parseapi-mcp",
|
|
3
|
-
"version": "1.
|
|
3
|
+
"version": "1.10.1",
|
|
4
4
|
"mcpName": "com.parseapi/mcp",
|
|
5
5
|
"description": "Official ParseAPI MCP server. Look up places, addresses, company numbers, email, phone, weather, dates and more.",
|
|
6
6
|
"keywords": [
|
|
@@ -50,7 +50,7 @@
|
|
|
50
50
|
"dependencies": {
|
|
51
51
|
"@modelcontextprotocol/node": "^2.0.0",
|
|
52
52
|
"@modelcontextprotocol/server": "^2.0.0",
|
|
53
|
-
"@parseapi/sdk": "1.
|
|
53
|
+
"@parseapi/sdk": "^1.11.1",
|
|
54
54
|
"zod": "^4.0.0"
|
|
55
55
|
},
|
|
56
56
|
"devDependencies": {
|