parseapi-mcp 1.7.1 → 1.9.0
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 +20 -5
- package/dist/{chunk-SCQMK735.js → chunk-TAT7ORUC.js} +229 -142
- 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
|
@@ -55,9 +55,9 @@ MCP packages older than 1.0.0 keep their existing behavior and use the team's de
|
|
|
55
55
|
|
|
56
56
|
## Tools
|
|
57
57
|
|
|
58
|
-
Full mode provides
|
|
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`, `email`, `vat`, `bank`, `bank_us_ach`, `bank_requirements`, `card`, `provider`, `vehicle`, `industry`, `industry_search`, `tariff`, `dns`, `asn`, `mac`, `currency_rate`, and the rest.
|
|
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`, `vehicle`, `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
|
|
|
@@ -80,6 +80,9 @@ Example tool arguments:
|
|
|
80
80
|
| `country_states` | `{"code":"US"}` |
|
|
81
81
|
| `address_search` | `{"query":"1600 Pennsylvania","country":"US","city":"Washington","state":"DC"}` |
|
|
82
82
|
| `company` | `{"number":"552100554","country":"FR"}` |
|
|
83
|
+
| `company_search` | `{"query":"Cloudflare","country":"US"}` |
|
|
84
|
+
| `company_id` | `{"id":"co_xw3f22es6cjq","deep":true}` |
|
|
85
|
+
| `company_coverage` | `{}` |
|
|
83
86
|
| `time` | `{}` (UTC now) |
|
|
84
87
|
| `time` | `{"timezone":"America/New_York","at":"2026-09-05T09:00:00","to":"Asia/Tokyo"}` |
|
|
85
88
|
| `time` | `{"lat":40.71,"lon":-74.01}` |
|
|
@@ -101,12 +104,24 @@ A path uses the same string formats with 2-512 vertices and a required integer `
|
|
|
101
104
|
|
|
102
105
|
Australian `postal` lookup returns core `localities` with suburb choices (`city`, `state`, `state_name`). Null or an omitted field means unknown, while `[]` means the reviewed reference has no eligible choices. A single choice can coexist with `city: null`. Ask for the user's suburb choice and preserve manual entry. These are geographic choices, not mailing-address verification. AU Postal tool results include a separate source notice after the JSON. [G-NAF source, adaptations and licence](https://parseapi.com/legal/attribution#postal-au).
|
|
103
106
|
|
|
104
|
-
|
|
107
|
+
Address lookup returns standardized components and registration status for the US and France. Its `deep` object is currently empty. National-number `company` lookup returns validity, registration status and business details when available. `address_search` also accepts `postal` and `ip` to narrow or rank matches. French search needs `country: "FR"` and either `postal` or `city`.
|
|
108
|
+
|
|
109
|
+
For the company directory, call `company_search` with at most one of `query`,
|
|
110
|
+
`domain`, `ticker` or `identifier`. Use `exchange` with a ticker and `authority`
|
|
111
|
+
with an identifier. Review the candidates, then pass the chosen `id` to
|
|
112
|
+
`company_id`. Send the returned `next` as `cursor` with the same selector,
|
|
113
|
+
filters and `limit` for another page. Directory deep adds detail in the same
|
|
114
|
+
pooled request on every plan and belongs to each company result.
|
|
115
|
+
Selected website descriptions, logos, socials and founding claims include
|
|
116
|
+
field-level sources. Logo URLs are returned without fetching images. Directory
|
|
117
|
+
tools do not accept `lang`. `company_coverage` describes the edition's records,
|
|
118
|
+
and empty listings do not establish private ownership. The existing `company`
|
|
119
|
+
tool continues to parse national registration numbers.
|
|
105
120
|
|
|
106
|
-
|
|
121
|
+
For discovery without an identity selector, supply `country` or both `industry` and `industry_type`. For example: `{ "country": "US", "industry": "0700", "industry_type": "sic" }`. SIC is the supported namespace; its exact four-digit code stays a string. Empty requests, incomplete industry pairs and multiple selectors are rejected. Country means the profile country. Filters intersect, unknown values do not match, and the same filters and limit must accompany a returned cursor. Filter-only candidates carry `match: { "field": "filters", "value": null }`.
|
|
107
122
|
|
|
108
123
|
|
|
109
|
-
|
|
124
|
+
Paid Deep also returns `taxonomies` in published order, with taxonomy code, specialty label, primary flag and provider-reported license number/state, plus `enumerated_at`, `updated_at` and `reactivated_at` record dates. Reported licenses are not verified licenses. Null lists mean unavailable; empty lists mean the edition contains no entries. Core `sources` is available on every plan: NPPES, LEIE, PECOS and opt-out each have nullable edition metadata (`edition`, `published_at`, `through`, `imported_at`). Provider record dates are separate from source publication and completed import dates. Older responses may omit these additions. Edition details remain null until a verified source is served.
|
|
110
125
|
|
|
111
126
|
Pass the original NPI as a string. `valid` checks its format and checksum; `registered` means a match in the stored NPPES snapshot. `active` reflects recorded NPI deactivation, not licensure. `excluded` is an NPI-only OIG LEIE match; `false` is not a complete exclusion clearance. These directory facts do not verify credentials, current practice contact or payment eligibility.
|
|
112
127
|
|
|
@@ -3,7 +3,7 @@
|
|
|
3
3
|
// src/registry.ts
|
|
4
4
|
import { McpServer } from "@modelcontextprotocol/server";
|
|
5
5
|
import { parseAPI } from "@parseapi/sdk";
|
|
6
|
-
import * as
|
|
6
|
+
import * as z4 from "zod";
|
|
7
7
|
|
|
8
8
|
// src/errors.ts
|
|
9
9
|
import { ParseAPIError } from "@parseapi/sdk";
|
|
@@ -932,9 +932,9 @@ function registerDiscovery(server, operations, mode, apiVersion) {
|
|
|
932
932
|
|
|
933
933
|
// src/preflight.ts
|
|
934
934
|
import * as z2 from "zod";
|
|
935
|
-
var
|
|
935
|
+
var preflightTaskSchema = z2.strictObject({
|
|
936
936
|
operations: z2.array(z2.strictObject({
|
|
937
|
-
operation: z2.enum(["email", "domain", "dns", "mx", "country"]),
|
|
937
|
+
operation: z2.enum(["email", "domain", "dns", "mx", "country", "vat", "carrier", "caller", "hlr", "ip", "phone", "postal"]),
|
|
938
938
|
count: z2.number().int().min(1).max(1e5),
|
|
939
939
|
deep: z2.boolean().optional()
|
|
940
940
|
})).min(1).max(20).refine((items) => items.reduce((sum, item) => sum + item.count, 0) <= 1e5, {
|
|
@@ -945,8 +945,8 @@ var task = z2.strictObject({
|
|
|
945
945
|
function registerPreflight(server, client, transport) {
|
|
946
946
|
server.registerTool("preflight", {
|
|
947
947
|
title: "Estimate ParseAPI task usage",
|
|
948
|
-
description: "Estimate whether your secret key permits a proposed Email, Domain, DNS, MX or
|
|
949
|
-
inputSchema:
|
|
948
|
+
description: "Estimate whether your secret key permits a proposed Email, VAT, Carrier, Caller, HLR, Domain, DNS, MX, Country, IP, Phone or Postal task, its advisory capacity, and additional USD charges under accepted terms. Supply operation counts and optional Deep, without lookup inputs. Uses default SDK retries: up to three attempts per ordinary lookup and one per metered lookup. Authenticated metadata request, no lookup units or paid checks. Reserves no units or money and does not enforce a budget. Check permitted, cost.status, capacity and budget before lookup.",
|
|
949
|
+
inputSchema: preflightTaskSchema,
|
|
950
950
|
annotations: { readOnlyHint: true, idempotentHint: true }
|
|
951
951
|
}, async (args, context) => {
|
|
952
952
|
if (!client) return noKeyResult(transport);
|
|
@@ -959,16 +959,65 @@ function registerPreflight(server, client, transport) {
|
|
|
959
959
|
});
|
|
960
960
|
}
|
|
961
961
|
|
|
962
|
+
// src/task.ts
|
|
963
|
+
import * as z3 from "zod";
|
|
964
|
+
function registerTasks(server, client, transport) {
|
|
965
|
+
const id = z3.string().regex(/^task_[a-f0-9]{40}$/);
|
|
966
|
+
const requestId = z3.string().regex(/^[A-Za-z0-9._:-]{1,128}$/).describe("Unique ID for the intended request. Reuse this exact ID and inputs on every retry. Never include private lookup values in it.");
|
|
967
|
+
const call = async (action) => {
|
|
968
|
+
if (!client) return noKeyResult(transport);
|
|
969
|
+
try {
|
|
970
|
+
const data = await action();
|
|
971
|
+
return { ...ok(data), structuredContent: data };
|
|
972
|
+
} catch (error) {
|
|
973
|
+
return toErrorResult(error);
|
|
974
|
+
}
|
|
975
|
+
};
|
|
976
|
+
server.registerTool("task_create", {
|
|
977
|
+
title: "Authorize a bounded task",
|
|
978
|
+
description: "Create a 24-hour task with allowed operations, lookup counts and an enforced USD limit on additional lookup charges. Requires already authorized user scope and a secret key. Reserves no account units and makes no lookups. Only task_lookup obeys this task budget. Ordinary lookups remain separate. Included units can make actual cost zero, but a positive-rate lookup needs budget room for its conservative full rate.",
|
|
979
|
+
inputSchema: preflightTaskSchema.safeExtend({ budget_usd: z3.string().regex(/^(?:0|[1-9]\d{0,6})(?:\.\d{1,2})?$/), request_id: requestId }).refine((args) => args.operations.reduce((sum, op) => sum + op.count, 0) <= 1e3, { message: "A task can authorize at most 1000 lookups." }).refine((args) => Number(args.budget_usd) <= 1e6, { message: "The task budget cannot exceed 1000000 USD." }),
|
|
980
|
+
annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
|
|
981
|
+
}, (args, context) => call(() => client.task({ operations: args.operations, budget_usd: args.budget_usd }, args.request_id, { signal: context.mcpReq.signal })));
|
|
982
|
+
server.registerTool("task_status", {
|
|
983
|
+
title: "Read task budget and progress",
|
|
984
|
+
description: "Read completed and allocated lookup counts, spent and reserved USD budget and expiry. No lookup or usage unit.",
|
|
985
|
+
inputSchema: z3.strictObject({ task_id: id }),
|
|
986
|
+
annotations: { readOnlyHint: true, idempotentHint: true }
|
|
987
|
+
}, (args, context) => call(() => client.task.get(args.task_id, { signal: context.mcpReq.signal })));
|
|
988
|
+
server.registerTool("task_cancel", {
|
|
989
|
+
title: "Cancel remaining task work",
|
|
990
|
+
description: "Prevent new lookups in this task. Already started lookups may finish and incur their reserved charge. Saved results remain recoverable.",
|
|
991
|
+
inputSchema: z3.strictObject({ task_id: id }),
|
|
992
|
+
annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
|
|
993
|
+
}, (args, context) => call(() => client.task.cancel(args.task_id, { signal: context.mcpReq.signal })));
|
|
994
|
+
server.registerTool("task_lookup", {
|
|
995
|
+
title: "Run or recover a bounded lookup",
|
|
996
|
+
description: "Run one lookup under an authorized task budget and count. Reuse request_id with identical inputs to recover its saved response without another lookup or usage charge. Inspect status_code and result, including nulls. task_in_progress or task_outcome_unknown means keep the same request_id; never use a new ID to repeat uncertain work. Saved results are available for 48 hours from task creation. This tool can consume pooled and metered units on its first execution.",
|
|
997
|
+
inputSchema: z3.strictObject({
|
|
998
|
+
task_id: id,
|
|
999
|
+
request_id: requestId,
|
|
1000
|
+
operation: z3.enum(["email", "vat", "carrier", "caller", "hlr", "domain", "dns", "mx", "country", "ip", "phone", "postal"]),
|
|
1001
|
+
value: z3.string().min(1).max(2048),
|
|
1002
|
+
country: z3.string().regex(/^[A-Za-z]{2}$/).optional(),
|
|
1003
|
+
deep: z3.boolean().optional()
|
|
1004
|
+
}),
|
|
1005
|
+
annotations: { readOnlyHint: true, idempotentHint: true }
|
|
1006
|
+
}, ({ task_id, request_id, ...input }, context) => call(() => client.task.lookup(task_id, input, request_id, { signal: context.mcpReq.signal })));
|
|
1007
|
+
}
|
|
1008
|
+
|
|
962
1009
|
// src/registry.ts
|
|
963
|
-
var VERSION = "1.
|
|
1010
|
+
var VERSION = "1.9.0";
|
|
964
1011
|
var API_VERSION = "2.0.0";
|
|
965
1012
|
var US_ROUTING_NOTICE = "Routing reference attribution: https://parseapi.com/legal/attribution#routing-numbers";
|
|
966
1013
|
var AU_POSTAL_NOTICE = "Incorporates or developed using G-NAF \xA9 Geoscape Australia licensed by the Commonwealth of Australia under the Open Geo-coded National Address File (G-NAF) End User Licence Agreement. Geographic choices are not mailing-address verification. Source, adaptations and licence: https://parseapi.com/legal/attribution#postal-au";
|
|
967
|
-
var deep =
|
|
968
|
-
var lat =
|
|
969
|
-
var lon =
|
|
970
|
-
var iso2 = (what) =>
|
|
971
|
-
var
|
|
1014
|
+
var deep = z4.boolean().optional().describe("Include the nested deep object when available. Pricing depends on the operation.");
|
|
1015
|
+
var lat = z4.number().min(-90).max(90).describe("Latitude in decimal degrees");
|
|
1016
|
+
var lon = z4.number().min(-180).max(180).describe("Longitude in decimal degrees");
|
|
1017
|
+
var iso2 = (what) => z4.string().describe(`ISO 3166-1 alpha-2 ${what}, e.g. US`);
|
|
1018
|
+
var tariffEdition = z4.string().regex(/^[a-f0-9]{64}$/).optional().describe("Exact immutable edition fingerprint. Without date, returns undated schedule context.");
|
|
1019
|
+
var tariffDate = z4.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional().describe("YYYY-MM-DD with verified source coverage. Combine with edition only when it covers this date.");
|
|
1020
|
+
var countryOpt = z4.string().optional().describe("ISO2, ISO3, or a country name. Optional when the lookup is unique.");
|
|
972
1021
|
var titleWords = {
|
|
973
1022
|
ip: "IP",
|
|
974
1023
|
asn: "ASN",
|
|
@@ -1021,7 +1070,7 @@ var languageTools = /* @__PURE__ */ new Set([
|
|
|
1021
1070
|
"emoji_search",
|
|
1022
1071
|
"point"
|
|
1023
1072
|
]);
|
|
1024
|
-
var displayLanguage =
|
|
1073
|
+
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.");
|
|
1025
1074
|
function buildServer(key, transport, options = {}) {
|
|
1026
1075
|
const mode = options.mode ?? "full";
|
|
1027
1076
|
if (mode !== "full" && mode !== "compact") throw new Error("Unknown MCP catalog mode");
|
|
@@ -1046,7 +1095,7 @@ function buildServer(key, transport, options = {}) {
|
|
|
1046
1095
|
}) : null;
|
|
1047
1096
|
function tool(name, description, shape, fn, refine) {
|
|
1048
1097
|
const localized = languageTools.has(name);
|
|
1049
|
-
const input =
|
|
1098
|
+
const input = z4.object(localized ? { ...shape, lang: displayLanguage } : shape);
|
|
1050
1099
|
const schema = refine ? refine(input) : input;
|
|
1051
1100
|
const invoke = async (args, signal) => {
|
|
1052
1101
|
if (!parse) return noKeyResult(transport);
|
|
@@ -1086,10 +1135,10 @@ function buildServer(key, transport, options = {}) {
|
|
|
1086
1135
|
"measure",
|
|
1087
1136
|
"Parse a measurement or convert it to a target unit. Supports mixed measurements such as 5 ft 11 in. Amount is a decimal string. Without to, returns the canonical unit for its type. Ambiguous input returns valid false, reason and choices. Use measure_units to discover accepted units. Pooled request, no separate check charge.",
|
|
1088
1137
|
{
|
|
1089
|
-
measure:
|
|
1090
|
-
to:
|
|
1091
|
-
locale:
|
|
1092
|
-
system:
|
|
1138
|
+
measure: z4.string().min(1).max(256).describe("Measurement to parse, e.g. 5 ft 11 in or 10 kg"),
|
|
1139
|
+
to: z4.string().min(1).max(128).optional().describe("Target unit, e.g. cm or lb"),
|
|
1140
|
+
locale: z4.string().min(1).max(32).optional().describe("Explicit number locale, e.g. de-DE"),
|
|
1141
|
+
system: z4.enum(["us", "imperial"]).optional().describe("Resolve an ambiguous customary unit using the stated system")
|
|
1093
1142
|
},
|
|
1094
1143
|
(c, a, request) => c.measure(a.measure, { ...request, to: a.to, locale: a.locale, system: a.system })
|
|
1095
1144
|
);
|
|
@@ -1097,16 +1146,16 @@ function buildServer(key, transport, options = {}) {
|
|
|
1097
1146
|
"measure_units",
|
|
1098
1147
|
"Discover the reviewed measurement units, canonical codes, types and aliases. With no filters, returns the full catalog. Pass unit to find compatible conversion targets. Combine query and type to narrow results.",
|
|
1099
1148
|
{
|
|
1100
|
-
query:
|
|
1101
|
-
type:
|
|
1102
|
-
unit:
|
|
1149
|
+
query: z4.string().max(128).optional().describe("Search text, e.g. foot"),
|
|
1150
|
+
type: z4.string().min(1).max(64).optional().describe("Measurement type, e.g. length"),
|
|
1151
|
+
unit: z4.string().min(1).max(128).optional().describe("Return units compatible with this unit, e.g. m")
|
|
1103
1152
|
},
|
|
1104
1153
|
(c, a, request) => c.measure.units({ ...request, query: a.query, type: a.type, unit: a.unit })
|
|
1105
1154
|
);
|
|
1106
1155
|
tool(
|
|
1107
1156
|
"ip",
|
|
1108
1157
|
"Look up an IPv4 or IPv6 address: country, region, ASN, timezone. Deep adds datacenter, relay, tor and vpn flags.",
|
|
1109
|
-
{ ip:
|
|
1158
|
+
{ ip: z4.string().describe("IPv4 or IPv6 address, e.g. 8.8.8.8"), deep },
|
|
1110
1159
|
(c, a, request) => c.ip(a.ip, { ...request, deep: a.deep })
|
|
1111
1160
|
);
|
|
1112
1161
|
if (transport === "stdio") {
|
|
@@ -1120,20 +1169,20 @@ function buildServer(key, transport, options = {}) {
|
|
|
1120
1169
|
tool(
|
|
1121
1170
|
"continent",
|
|
1122
1171
|
"Look up a continent by code: name, area and population.",
|
|
1123
|
-
{ code:
|
|
1172
|
+
{ code: z4.string().describe("Continent code: AF, AN, AS, EU, NA, OC, SA") },
|
|
1124
1173
|
(c, a, request) => c.continent(a.code, request)
|
|
1125
1174
|
);
|
|
1126
1175
|
tool(
|
|
1127
1176
|
"continent_countries",
|
|
1128
1177
|
"List every country on a continent.",
|
|
1129
|
-
{ code:
|
|
1178
|
+
{ code: z4.string().describe("Continent code: AF, AN, AS, EU, NA, OC, SA") },
|
|
1130
1179
|
(c, a, request) => c.continent.countries(a.code, request)
|
|
1131
1180
|
);
|
|
1132
1181
|
tool(
|
|
1133
1182
|
"bloc",
|
|
1134
1183
|
"Look up a country group by code: EU, EEA, Schengen, Eurozone, SEPA, NATO, and more. Returns the official name and the current member count.",
|
|
1135
1184
|
{
|
|
1136
|
-
code:
|
|
1185
|
+
code: z4.string().describe("Bloc code: EU, EEA, EFTA, SCHENGEN, EUROZONE, SEPA, NATO, OECD, G7, ASEAN, GCC, MERCOSUR")
|
|
1137
1186
|
},
|
|
1138
1187
|
(c, a, request) => c.bloc(a.code, request)
|
|
1139
1188
|
);
|
|
@@ -1141,7 +1190,7 @@ function buildServer(key, transport, options = {}) {
|
|
|
1141
1190
|
"bloc_countries",
|
|
1142
1191
|
"List the current members of a country group, each with name, flag, and calling code.",
|
|
1143
1192
|
{
|
|
1144
|
-
code:
|
|
1193
|
+
code: z4.string().describe("Bloc code: EU, EEA, EFTA, SCHENGEN, EUROZONE, SEPA, NATO, OECD, G7, ASEAN, GCC, MERCOSUR")
|
|
1145
1194
|
},
|
|
1146
1195
|
(c, a, request) => c.bloc.countries(a.code, request)
|
|
1147
1196
|
);
|
|
@@ -1161,7 +1210,7 @@ function buildServer(key, transport, options = {}) {
|
|
|
1161
1210
|
"state",
|
|
1162
1211
|
"Look up a state or province by code or name. Deep adds its demographic and tax profile on paid plans, including population_period when verified. Pass country to resolve a colliding code.",
|
|
1163
1212
|
{
|
|
1164
|
-
code:
|
|
1213
|
+
code: z4.string().describe("State code or name, e.g. colorado, NC"),
|
|
1165
1214
|
country: countryOpt,
|
|
1166
1215
|
deep: deep.describe("Include the complete detail bag on a paid plan.")
|
|
1167
1216
|
},
|
|
@@ -1171,7 +1220,7 @@ function buildServer(key, transport, options = {}) {
|
|
|
1171
1220
|
"state_districts",
|
|
1172
1221
|
"List the districts, counties or departments of a state. Deep adds population and its reporting period to each result on paid plans.",
|
|
1173
1222
|
{
|
|
1174
|
-
code:
|
|
1223
|
+
code: z4.string().describe("State code or name, e.g. NC, colorado"),
|
|
1175
1224
|
country: countryOpt,
|
|
1176
1225
|
deep: deep.describe("Include population and its reporting period in each district detail bag on a paid plan.")
|
|
1177
1226
|
},
|
|
@@ -1181,9 +1230,9 @@ function buildServer(key, transport, options = {}) {
|
|
|
1181
1230
|
"district",
|
|
1182
1231
|
"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. Population includes a reporting year or period when verified. 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.",
|
|
1183
1232
|
{
|
|
1184
|
-
code:
|
|
1233
|
+
code: z4.string().describe("District code or name, e.g. 37081, guilford county"),
|
|
1185
1234
|
country: countryOpt,
|
|
1186
|
-
state:
|
|
1235
|
+
state: z4.string().optional().describe("ADM1 code or name to disambiguate, e.g. NC or louisiana"),
|
|
1187
1236
|
deep: deep.describe("Include the complete detail bag on a paid plan.")
|
|
1188
1237
|
},
|
|
1189
1238
|
(c, a, request) => c.district(a.code, { ...request, deep: a.deep, country: a.country, state: a.state })
|
|
@@ -1192,9 +1241,9 @@ function buildServer(key, transport, options = {}) {
|
|
|
1192
1241
|
"city",
|
|
1193
1242
|
"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. Population includes a reporting year or period when verified.",
|
|
1194
1243
|
{
|
|
1195
|
-
name:
|
|
1244
|
+
name: z4.string().describe("City name, e.g. charlotte"),
|
|
1196
1245
|
country: countryOpt,
|
|
1197
|
-
state:
|
|
1246
|
+
state: z4.string().optional().describe("State code to disambiguate, e.g. NC"),
|
|
1198
1247
|
deep: deep.describe("Include the complete detail bag on a paid plan.")
|
|
1199
1248
|
},
|
|
1200
1249
|
(c, a, request) => c.city(a.name, { ...request, deep: a.deep, country: a.country, state: a.state })
|
|
@@ -1202,17 +1251,17 @@ function buildServer(key, transport, options = {}) {
|
|
|
1202
1251
|
tool(
|
|
1203
1252
|
"city_id",
|
|
1204
1253
|
"Resolve a stable city id. Deep adds the city profile on paid plans.",
|
|
1205
|
-
{ id:
|
|
1254
|
+
{ id: z4.string().describe("Stable city id, e.g. city_mb8mbqrkz8zb"), deep: deep.describe("Include the complete detail bag on a paid plan.") },
|
|
1206
1255
|
(c, a, request) => c.city.id(a.id, { ...request, deep: a.deep })
|
|
1207
1256
|
);
|
|
1208
1257
|
tool(
|
|
1209
1258
|
"city_search",
|
|
1210
1259
|
"Search city names. Deep adds the profile inside each returned city on paid plans.",
|
|
1211
1260
|
{
|
|
1212
|
-
query:
|
|
1261
|
+
query: z4.string().describe("Name prefix, e.g. char"),
|
|
1213
1262
|
country: countryOpt,
|
|
1214
|
-
state:
|
|
1215
|
-
limit:
|
|
1263
|
+
state: z4.string().optional().describe("State code filter"),
|
|
1264
|
+
limit: z4.number().int().min(1).max(50).optional().describe("Max results"),
|
|
1216
1265
|
deep: deep.describe("Include the complete detail bag on a paid plan.")
|
|
1217
1266
|
},
|
|
1218
1267
|
(c, a, request) => c.city.search(a.query, { ...request, deep: a.deep, country: a.country, state: a.state, limit: a.limit })
|
|
@@ -1227,12 +1276,12 @@ function buildServer(key, transport, options = {}) {
|
|
|
1227
1276
|
"city_nearby",
|
|
1228
1277
|
"Find nearby cities with distances. Deep adds the profile inside each returned city on paid plans.",
|
|
1229
1278
|
{
|
|
1230
|
-
name:
|
|
1279
|
+
name: z4.string().describe("Anchor city name, e.g. denver"),
|
|
1231
1280
|
country: countryOpt,
|
|
1232
|
-
state:
|
|
1233
|
-
radius:
|
|
1234
|
-
unit:
|
|
1235
|
-
limit:
|
|
1281
|
+
state: z4.string().optional().describe("State code to disambiguate the anchor"),
|
|
1282
|
+
radius: z4.number().positive().optional().describe("Search radius, default 40 km"),
|
|
1283
|
+
unit: z4.enum(["km", "mi"]).optional().describe("Radius unit, default km"),
|
|
1284
|
+
limit: z4.number().int().min(1).max(50).optional().describe("Max results, default 10"),
|
|
1236
1285
|
deep: deep.describe("Include the complete detail bag on a paid plan.")
|
|
1237
1286
|
},
|
|
1238
1287
|
(c, a, request) => c.city.nearby(a.name, {
|
|
@@ -1249,7 +1298,7 @@ function buildServer(key, transport, options = {}) {
|
|
|
1249
1298
|
"postal",
|
|
1250
1299
|
"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 with its reporting period, 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.",
|
|
1251
1300
|
{
|
|
1252
|
-
code:
|
|
1301
|
+
code: z4.string().describe("Postal or ZIP code, e.g. SW1A 1AA, 28202"),
|
|
1253
1302
|
country: countryOpt,
|
|
1254
1303
|
deep: deep.describe("Include the complete detail bag on a paid plan.")
|
|
1255
1304
|
},
|
|
@@ -1259,10 +1308,10 @@ function buildServer(key, transport, options = {}) {
|
|
|
1259
1308
|
"postal_nearby",
|
|
1260
1309
|
"Find nearby postal codes with distances. Deep adds metropolitan associations to the origin and each result on paid plans.",
|
|
1261
1310
|
{
|
|
1262
|
-
code:
|
|
1311
|
+
code: z4.string().describe("Postal code to search around"),
|
|
1263
1312
|
country: countryOpt,
|
|
1264
|
-
radius:
|
|
1265
|
-
unit:
|
|
1313
|
+
radius: z4.number().positive().optional().describe("Search radius"),
|
|
1314
|
+
unit: z4.enum(["km", "mi"]).optional().describe("Radius unit, default km"),
|
|
1266
1315
|
deep: deep.describe("Include the complete detail bag on a paid plan.")
|
|
1267
1316
|
},
|
|
1268
1317
|
(c, a, request) => c.postal.nearby(a.code, { ...request, deep: a.deep, country: a.country, radius: a.radius, unit: a.unit })
|
|
@@ -1271,8 +1320,8 @@ function buildServer(key, transport, options = {}) {
|
|
|
1271
1320
|
"postal_distance",
|
|
1272
1321
|
"Distance between two postal codes. Deep adds metropolitan associations inside each endpoint on paid plans.",
|
|
1273
1322
|
{
|
|
1274
|
-
from:
|
|
1275
|
-
to:
|
|
1323
|
+
from: z4.string().describe("First postal code"),
|
|
1324
|
+
to: z4.string().describe("Second postal code"),
|
|
1276
1325
|
country: countryOpt,
|
|
1277
1326
|
deep: deep.describe("Include the complete detail bag on a paid plan.")
|
|
1278
1327
|
},
|
|
@@ -1282,8 +1331,8 @@ function buildServer(key, transport, options = {}) {
|
|
|
1282
1331
|
"address",
|
|
1283
1332
|
"Look up a US or French street address: house number, street, unit, city, state, postal code and registration status. Registration does not establish deliverability or verify an apartment. Deep is currently an empty object.",
|
|
1284
1333
|
{
|
|
1285
|
-
address:
|
|
1286
|
-
country:
|
|
1334
|
+
address: z4.string().describe("Street address, e.g. 1600 Pennsylvania Ave NW, Washington, DC 20500"),
|
|
1335
|
+
country: z4.string().optional().describe("Country: US or FR. Use FR or a written France suffix for France. Defaults to US."),
|
|
1287
1336
|
deep
|
|
1288
1337
|
},
|
|
1289
1338
|
(c, a, request) => c.address(a.address, { ...request, country: a.country, deep: a.deep })
|
|
@@ -1292,12 +1341,12 @@ function buildServer(key, transport, options = {}) {
|
|
|
1292
1341
|
"address_search",
|
|
1293
1342
|
"Search street addresses from a partial address. Prefer postal, or city and state, from the form. An optional end-user IP hints at locality. Empty results explain themselves with reason: more_input, missing_context or no_matches. With suggestions reason is null. Operational failures use API errors. French search requires country FR and either postal or city.",
|
|
1294
1343
|
{
|
|
1295
|
-
query:
|
|
1296
|
-
country:
|
|
1297
|
-
postal:
|
|
1298
|
-
city:
|
|
1299
|
-
state:
|
|
1300
|
-
ip:
|
|
1344
|
+
query: z4.string().describe("Partial street address, e.g. 1600 Pennsylvania"),
|
|
1345
|
+
country: z4.string().optional().describe("Country: US or FR. Defaults to US."),
|
|
1346
|
+
postal: z4.string().optional().describe("Postal code from the address form, preferred for locality context"),
|
|
1347
|
+
city: z4.string().optional().describe("City filter"),
|
|
1348
|
+
state: z4.string().optional().describe("State code filter"),
|
|
1349
|
+
ip: z4.string().optional().describe("End-user IP locality hint for server-side calls. Prefer explicit form context.")
|
|
1301
1350
|
},
|
|
1302
1351
|
(c, a, request) => c.address.search(a.query, { ...request, country: a.country, postal: a.postal, city: a.city, state: a.state, ip: a.ip })
|
|
1303
1352
|
);
|
|
@@ -1305,12 +1354,47 @@ function buildServer(key, transport, options = {}) {
|
|
|
1305
1354
|
"company",
|
|
1306
1355
|
"Parse a company number and its registered identity, status and address. Paid deep adds business activity and associated identifiers. Geography lookups are separate calls.",
|
|
1307
1356
|
{
|
|
1308
|
-
number:
|
|
1357
|
+
number: z4.string().describe("Company registration number, e.g. 552100554 with country FR"),
|
|
1309
1358
|
country: countryOpt,
|
|
1310
1359
|
deep
|
|
1311
1360
|
},
|
|
1312
1361
|
(c, a, request) => c.company(a.number, { ...request, country: a.country, deep: a.deep })
|
|
1313
1362
|
);
|
|
1363
|
+
tool(
|
|
1364
|
+
"company_id",
|
|
1365
|
+
"Look up a company directory profile by its stable co_ ID. Deep adds legal/reference details and selected description, logo, domains, social_profiles (platform, url, handle), phone_numbers and email_addresses (with source-reported type), founding precision, reported employees and field-level sources when available. Employee counts retain their measurement date, organization scope and approximation flag; null means unknown. A website claim is not legal ownership proof. National registration numbers use company.",
|
|
1366
|
+
{ id: z4.string().min(1).describe("Stable company directory ID returned by company_search"), deep },
|
|
1367
|
+
(c, a, request) => c.company.id(a.id, { ...request, deep: a.deep })
|
|
1368
|
+
);
|
|
1369
|
+
tool(
|
|
1370
|
+
"company_search",
|
|
1371
|
+
"Find company directory candidates using at most one of query, domain, ticker or identifier, or discover by country, an exact industry pair. Returns companies and an opaque next cursor without choosing a match. Deep belongs to each result. Keep the same selector, filters and limit when sending cursor. Empty listings do not establish private ownership.",
|
|
1372
|
+
{
|
|
1373
|
+
query: z4.string().min(1).optional().describe("Company name search, sent as q"),
|
|
1374
|
+
domain: z4.string().min(1).optional().describe("Company website domain or URL"),
|
|
1375
|
+
ticker: z4.string().min(1).optional().describe("Security ticker, optionally scoped by exchange"),
|
|
1376
|
+
identifier: z4.string().min(1).optional().describe("Business identifier, preserving leading zeros"),
|
|
1377
|
+
country: z4.string().regex(/^[A-Za-z]{2}$/).optional().describe("ISO2 profile-country filter; does not mean headquarters or operating presence"),
|
|
1378
|
+
industry: z4.string().regex(/^[0-9]{4}$/).optional().describe("Exact four-digit SIC code string, preserving leading zeros; requires industry_type"),
|
|
1379
|
+
industry_type: z4.literal("sic").optional().describe("Industry namespace; currently sic; requires industry"),
|
|
1380
|
+
exchange: z4.string().optional().describe("Exchange filter for ticker searches"),
|
|
1381
|
+
authority: z4.string().optional().describe("Issuing authority filter for identifier searches"),
|
|
1382
|
+
limit: z4.number().int().min(1).max(50).optional().describe("Maximum candidates on this page, from 1 to 50"),
|
|
1383
|
+
cursor: z4.string().optional().describe("Opaque next cursor returned by the same search"),
|
|
1384
|
+
deep
|
|
1385
|
+
},
|
|
1386
|
+
(c, a, request) => c.company.search({ ...request, query: a.query, domain: a.domain, ticker: a.ticker, identifier: a.identifier, country: a.country, industry: a.industry, industry_type: a.industry_type, exchange: a.exchange, authority: a.authority, limit: a.limit, cursor: a.cursor, deep: a.deep }),
|
|
1387
|
+
(schema) => schema.refine((args) => args.industry === void 0 === (args.industry_type === void 0), { message: "Supply industry and industry_type together." }).refine((args) => {
|
|
1388
|
+
const selectors = [args.query, args.domain, args.ticker, args.identifier].filter((value) => value !== void 0).length;
|
|
1389
|
+
return selectors <= 1 && (selectors === 1 || args.country !== void 0 || args.industry !== void 0 && args.industry_type !== void 0);
|
|
1390
|
+
}, { message: "Use at most one selector, or supply country, a complete industry pair." })
|
|
1391
|
+
);
|
|
1392
|
+
tool(
|
|
1393
|
+
"company_coverage",
|
|
1394
|
+
"Describe the company directory edition, countries and record counts. Counts describe this edition and do not establish complete country or worldwide coverage. A missing profile does not establish that a company does not exist.",
|
|
1395
|
+
{},
|
|
1396
|
+
(c, _a, request) => c.company.coverage(request)
|
|
1397
|
+
);
|
|
1314
1398
|
tool(
|
|
1315
1399
|
"point",
|
|
1316
1400
|
"Locate coordinates in their country, state, district and actual IANA timezone. Deep adds terrain and a compact nearest-city summary on every plan. The timezone ID stays in core. Nearest city is null when none is within 200 km.",
|
|
@@ -1323,9 +1407,9 @@ function buildServer(key, transport, options = {}) {
|
|
|
1323
1407
|
{
|
|
1324
1408
|
lat: lat.optional(),
|
|
1325
1409
|
lon: lon.optional(),
|
|
1326
|
-
points:
|
|
1327
|
-
path:
|
|
1328
|
-
samples:
|
|
1410
|
+
points: z4.string().min(1).max(12e3).optional().describe("lat,lon pairs separated by |, or enc: followed by a Google polyline. At most 512 points and 12000 characters. Omit lat and lon."),
|
|
1411
|
+
path: z4.string().min(1).max(12e3).optional().describe("Path with 2-512 vertices as lat,lon pairs separated by |, or enc: followed by a Google polyline. At most 12000 characters. Segments follow the shortest great-circle arc. Segments with antipodal endpoints are invalid. Requires samples. Omit lat, lon and points."),
|
|
1412
|
+
samples: z4.number().int().min(2).max(512).optional().describe("Number of evenly spaced samples along the path, including both endpoints. Required with path and invalid without it.")
|
|
1329
1413
|
},
|
|
1330
1414
|
(c, a, request) => {
|
|
1331
1415
|
if (a.path !== void 0) {
|
|
@@ -1348,23 +1432,23 @@ function buildServer(key, transport, options = {}) {
|
|
|
1348
1432
|
lat,
|
|
1349
1433
|
lon,
|
|
1350
1434
|
deep,
|
|
1351
|
-
date:
|
|
1435
|
+
date: z4.string().optional().describe("A past UTC day, YYYY-MM-DD. Requires paid deep. Adds deep.history alongside current conditions.")
|
|
1352
1436
|
},
|
|
1353
1437
|
(c, a, request) => c.weather(a.lat, a.lon, { ...request, deep: a.deep, date: a.date })
|
|
1354
1438
|
);
|
|
1355
1439
|
tool(
|
|
1356
1440
|
"email",
|
|
1357
1441
|
"Validate an email address: syntax, domain, mail routing, consumer mailbox, disposable, role, reserved domain type and typo suggestion. Deep adds mailbox deliverability, catch-all, status and the reason for the result, such as mailbox_full or mailbox_not_found. It also includes a suggested first name, no-reply flag, plus-address tag and mail service, such as Google or Microsoft. The suggested name is not a verified identity. Unavailable details are null.",
|
|
1358
|
-
{ email:
|
|
1442
|
+
{ email: z4.string().describe("Email address to validate"), deep },
|
|
1359
1443
|
(c, a, request) => c.email(a.email, { ...request, deep: a.deep })
|
|
1360
1444
|
);
|
|
1361
1445
|
tool(
|
|
1362
1446
|
"vat",
|
|
1363
1447
|
"Validate a VAT number: format and checksum on every call. Deep asks the live EU registry for registered, legal name, and address. Pass from with your own VAT for a consultation identifier.",
|
|
1364
1448
|
{
|
|
1365
|
-
number:
|
|
1449
|
+
number: z4.string().describe("VAT number, with or without the country prefix"),
|
|
1366
1450
|
country: iso2("country code when the number has no prefix").optional(),
|
|
1367
|
-
from:
|
|
1451
|
+
from: z4.string().optional().describe("Your own VAT number. Returns a consultation identifier for your audit file"),
|
|
1368
1452
|
deep
|
|
1369
1453
|
},
|
|
1370
1454
|
(c, a, request) => c.vat(a.number, { ...request, country: a.country, from: a.from, deep: a.deep })
|
|
@@ -1373,7 +1457,7 @@ function buildServer(key, transport, options = {}) {
|
|
|
1373
1457
|
"iban",
|
|
1374
1458
|
"Parse an IBAN and check its format, ISO checksum, and published national BBAN checks, with known bank identifiers. Deep adds check digits, branch and account decomposition on every plan. Does not verify an account exists.",
|
|
1375
1459
|
{
|
|
1376
|
-
iban:
|
|
1460
|
+
iban: z4.string().describe("IBAN, with or without spaces, with or without the country prefix"),
|
|
1377
1461
|
country: iso2("country code when the number has no prefix").optional(),
|
|
1378
1462
|
deep: deep.describe("Include optional detail on every plan.")
|
|
1379
1463
|
},
|
|
@@ -1383,8 +1467,8 @@ function buildServer(key, transport, options = {}) {
|
|
|
1383
1467
|
"bin",
|
|
1384
1468
|
"Look up a 6-11 digit payment-card prefix. Returns the actual longest matched prefix, issuer, country, brand key, brand name, card type and prepaid status where known. Unknown fields are null. Does not confirm a card or account exists. Pooled request on every plan.",
|
|
1385
1469
|
{
|
|
1386
|
-
bin:
|
|
1387
|
-
deep:
|
|
1470
|
+
bin: z4.string().describe("Card prefix as a string, 6-11 digits. Preserve leading zeros. Spaces and hyphens are accepted."),
|
|
1471
|
+
deep: z4.boolean().optional().describe("Include an empty deep object. No extra fields or separate charge.")
|
|
1388
1472
|
},
|
|
1389
1473
|
(c, a, request) => c.bin(a.bin, { ...request, deep: a.deep })
|
|
1390
1474
|
);
|
|
@@ -1392,7 +1476,7 @@ function buildServer(key, transport, options = {}) {
|
|
|
1392
1476
|
"npi",
|
|
1393
1477
|
"Validate an NPI and identify the registered provider, active/exclusion status, specialty and practice contact. Paid deep adds deactivation date and Medicare enrollment evidence.",
|
|
1394
1478
|
{
|
|
1395
|
-
npi:
|
|
1479
|
+
npi: z4.string().describe("10-digit NPI number"),
|
|
1396
1480
|
deep
|
|
1397
1481
|
},
|
|
1398
1482
|
(c, a, request) => c.npi(a.npi, { ...request, deep: a.deep })
|
|
@@ -1401,7 +1485,7 @@ function buildServer(key, transport, options = {}) {
|
|
|
1401
1485
|
"bank",
|
|
1402
1486
|
"Send an IBAN in a POST JSON body, keeping it out of the request URL. Parse with core checks and issues for input, country, length, structure, ISO checksum and supported national checks. not_supported is not a failed national check. Known bank names and BICs are independent nullable directory facts. Deep adds check digits, branch, the BBAN account remainder and source edition/match grain when a directory lookup ran, on every plan. Does not verify account existence, ownership or payment reachability.",
|
|
1403
1487
|
{
|
|
1404
|
-
iban:
|
|
1488
|
+
iban: z4.string().describe("Original IBAN input, with or without the country prefix. Preserve characters exactly so the API can report invalid input. Do not strip punctuation or decode percent escapes."),
|
|
1405
1489
|
country: iso2("country code when the number has no prefix").optional(),
|
|
1406
1490
|
deep: deep.describe("Include optional detail on every plan.")
|
|
1407
1491
|
},
|
|
@@ -1411,8 +1495,8 @@ function buildServer(key, transport, options = {}) {
|
|
|
1411
1495
|
"bank_us_ach",
|
|
1412
1496
|
"Check US routing-number format and ABA checksum plus account-field syntax. Sends original strings in a POST JSON body. No universal account checksum is available. A nullable bank_name is routing-directory identity only; this does not establish ACH eligibility, account existence or ownership. No deep option.",
|
|
1413
1497
|
{
|
|
1414
|
-
routing:
|
|
1415
|
-
account:
|
|
1498
|
+
routing: z4.string().describe("Original US routing string. Preserve leading zeros and characters; the API validates accepted separators."),
|
|
1499
|
+
account: z4.string().describe("Original account string. Preserve all characters, letter case and leading zeros; do not trim, normalize or decode.")
|
|
1416
1500
|
},
|
|
1417
1501
|
(c, a, request) => c.bankUsAch({ routing: a.routing, account: a.account }, request)
|
|
1418
1502
|
);
|
|
@@ -1421,7 +1505,7 @@ function buildServer(key, transport, options = {}) {
|
|
|
1421
1505
|
"Describe supported Bank input fields, normalization rules, check scope and limitations for a country and format. Metadata only: support does not establish directory completeness or payment reachability.",
|
|
1422
1506
|
{
|
|
1423
1507
|
country: iso2("country code"),
|
|
1424
|
-
format:
|
|
1508
|
+
format: z4.string().optional().describe("Input format, currently iban (default) or us_ach. Unknown formats report supported false.")
|
|
1425
1509
|
},
|
|
1426
1510
|
(c, a, request) => c.bankRequirements(a.country, { ...request, format: a.format })
|
|
1427
1511
|
);
|
|
@@ -1429,7 +1513,7 @@ function buildServer(key, transport, options = {}) {
|
|
|
1429
1513
|
"card",
|
|
1430
1514
|
"Identify a network and its CDN SVG logo from 2-11 leading digits, including processor-provided BIN/IIN prefixes. Unknown or ambiguous networks return null brand and a generic logo. Optional deep adds the longest recorded prefix, issuer, country, funding type and nullable prepaid status. Core identity is independent of issuer coverage. A shorter deep.prefix is broader coverage; missing fields never inherit from a parent row. Partial reference data does not prove card validity, account existence or payment acceptance. One pooled request on every plan, including deep.",
|
|
1431
1515
|
{
|
|
1432
|
-
bin:
|
|
1516
|
+
bin: z4.string().max(64, "Send a prefix only: 2-11 digits.").regex(/^[ \t\r\n-]*(?:[0-9][ \t\r\n-]*){2,11}$/, "Send a prefix only: 2-11 digits.").describe("Processor-provided leading digits as a string, 2-11 ASCII digits. Preserve zeros. Only ASCII space, tab, CR, LF and hyphen separators; at most 64 raw characters. Never send a full card number. Six or more digits enable issuer lookup."),
|
|
1433
1517
|
deep: deep.describe("Include recorded issuer details, pooled on every plan. Omitted by default; fewer than six digits returns all-null Deep fields.")
|
|
1434
1518
|
},
|
|
1435
1519
|
(c, a, request) => c.card(a.bin, { ...request, deep: a.deep })
|
|
@@ -1438,7 +1522,7 @@ function buildServer(key, transport, options = {}) {
|
|
|
1438
1522
|
"provider",
|
|
1439
1523
|
"Look up an NPI in stored provider-directory sources. valid is format/checksum only; registered means found in the NPPES snapshot; active is recorded NPI activation, not licensure. excluded is an NPI-only OIG LEIE match, and false is not complete exclusion clearance. Returns identity, specialty and practice contact where held. Core sources provides nullable edition metadata on every plan. Paid deep adds all published taxonomies and reported license details, provider enumeration/update/reactivation dates, deactivation date, Medicare enrollment, opt-out and enrollment rows. Reported licenses are not verified licenses; provider update dates are not source freshness. Null means unknown. No live credential or payment-eligibility verification. Pooled request; no separate check meter.",
|
|
1440
1524
|
{
|
|
1441
|
-
npi:
|
|
1525
|
+
npi: z4.string().describe("Original NPI input as a string, normally 10 digits. Preserve the input; invalid values return valid=false with unknown provider fields. Do not URI-decode it."),
|
|
1442
1526
|
deep: deep.describe("Include taxonomies, enumerated_at, updated_at, reactivated_at, deactivated_at, medicare, opt_out and enrollments from stored sources on paid plans. Omitted by default; Free returns {}. Null lists are unavailable; [] means the source recorded no rows.")
|
|
1443
1527
|
},
|
|
1444
1528
|
(c, a, request) => c.provider(a.npi, { ...request, deep: a.deep })
|
|
@@ -1447,7 +1531,7 @@ function buildServer(key, transport, options = {}) {
|
|
|
1447
1531
|
"phone",
|
|
1448
1532
|
"Parse and validate a phone number with national and international display formats. Deep adds numbering-plan state and timezone on every plan. These do not locate a handset.",
|
|
1449
1533
|
{
|
|
1450
|
-
number:
|
|
1534
|
+
number: z4.string().describe("Phone number, e.g. +14155552671"),
|
|
1451
1535
|
country: iso2("country code for national-format numbers").optional(),
|
|
1452
1536
|
deep
|
|
1453
1537
|
},
|
|
@@ -1457,7 +1541,7 @@ function buildServer(key, transport, options = {}) {
|
|
|
1457
1541
|
"carrier",
|
|
1458
1542
|
"Look up current carrier, real line type and burner flag. Deep adds issuing city and state in the same metered lookup, including Free allowance units. No extra check or second paid gate.",
|
|
1459
1543
|
{
|
|
1460
|
-
number:
|
|
1544
|
+
number: z4.string().describe("Phone number, e.g. +14155552671"),
|
|
1461
1545
|
country: iso2("country code for national-format numbers").optional(),
|
|
1462
1546
|
deep: deep.describe("Include available detail within the same metered core unit. No extra charge or paid-plan gate.")
|
|
1463
1547
|
},
|
|
@@ -1467,7 +1551,7 @@ function buildServer(key, transport, options = {}) {
|
|
|
1467
1551
|
"caller",
|
|
1468
1552
|
"Look up the caller ID name (CNAM) for a NANP (+1) phone number. caller is the record verbatim, null when no record or outside NANP. Metered per lookup on a NANP number.",
|
|
1469
1553
|
{
|
|
1470
|
-
number:
|
|
1554
|
+
number: z4.string().describe("Phone number, e.g. +18004633339"),
|
|
1471
1555
|
country: iso2("country code for national-format numbers").optional()
|
|
1472
1556
|
},
|
|
1473
1557
|
(c, a, request) => c.caller(a.number, { ...request, country: a.country })
|
|
@@ -1476,7 +1560,7 @@ function buildServer(key, transport, options = {}) {
|
|
|
1476
1560
|
"hlr",
|
|
1477
1561
|
"Phone status at the last check: live means assigned and connected means reachable at that check. Cached results may be returned. Deep adds available roaming and network diagnostics in the same metered lookup, including Free allowance units. Null is unconfirmed.",
|
|
1478
1562
|
{
|
|
1479
|
-
number:
|
|
1563
|
+
number: z4.string().describe("Phone number, e.g. +447712345678"),
|
|
1480
1564
|
country: iso2("country code for national-format numbers").optional(),
|
|
1481
1565
|
deep: deep.describe("Include available detail within the same metered core unit. No extra charge or paid-plan gate.")
|
|
1482
1566
|
},
|
|
@@ -1485,88 +1569,90 @@ function buildServer(key, transport, options = {}) {
|
|
|
1485
1569
|
tool(
|
|
1486
1570
|
"stack",
|
|
1487
1571
|
"Identify website technologies and available versions by category. Requires a hostname only. CMS, servers, frameworks, ecommerce, analytics, chat, payments and hosting are arrays of technology, name and nullable version. checked_at gives the check time. Scope is homepage or site; pages counts successfully checked HTML pages. Partial is true for homepage-only or incomplete bounded checks, false only when known in-scope candidates finished, never a guarantee every page was visited. When no page could be checked, checked_at and all categories are null, pages is 0 and partial is null. Empty arrays mean no matches. Missing detections do not prove absence. Uses one request from the plan allowance. Successful checks may be reused for up to 24 hours.",
|
|
1488
|
-
{ domain:
|
|
1572
|
+
{ domain: z4.string().min(1).max(253).describe("Public website hostname only, e.g. example.com. No scheme, path, port or IP address."), pretty: z4.boolean().optional().describe("Format the JSON response.") },
|
|
1489
1573
|
(c, a, request) => c.stack(a.domain, { ...request, pretty: a.pretty })
|
|
1490
1574
|
);
|
|
1491
1575
|
tool(
|
|
1492
1576
|
"domain",
|
|
1493
1577
|
"Check whether a domain is registered. Deep adds registration dates, registrar, status and DNSSEC, included on paid plans. Use dns for DNS records and mx for mail routing.",
|
|
1494
|
-
{ domain:
|
|
1578
|
+
{ domain: z4.string().describe("Domain name, e.g. example.com"), deep: deep.describe("Include registration details on a paid plan.") },
|
|
1495
1579
|
(c, a, request) => c.domain(a.domain, { ...request, deep: a.deep })
|
|
1496
1580
|
);
|
|
1497
1581
|
tool(
|
|
1498
1582
|
"asn",
|
|
1499
1583
|
"Network name and country for an autonomous system number.",
|
|
1500
|
-
{ asn:
|
|
1584
|
+
{ asn: z4.string().describe("Autonomous system number, such as AS13335 or 13335") },
|
|
1501
1585
|
(c, a, request) => c.asn(a.asn, request)
|
|
1502
1586
|
);
|
|
1503
1587
|
tool(
|
|
1504
1588
|
"mac",
|
|
1505
1589
|
"Normalize a 48-bit MAC address and return its registered assignment holder, local flag, and multicast flag. Vendor is null for local or multicast addresses.",
|
|
1506
|
-
{ mac:
|
|
1590
|
+
{ mac: z4.string().describe("MAC address") },
|
|
1507
1591
|
(c, a, request) => c.mac(a.mac, request)
|
|
1508
1592
|
);
|
|
1509
1593
|
tool(
|
|
1510
1594
|
"dns",
|
|
1511
1595
|
"Look up published DNS records with TTLs. Pooled on every plan. Omit type to check all ten supported types. The selected question may include its CNAME chain. Values retain DNS presentation syntax, including TXT quoting.",
|
|
1512
1596
|
{
|
|
1513
|
-
domain:
|
|
1514
|
-
type:
|
|
1597
|
+
domain: z4.string().describe("Domain or DNS name, including service names such as _dmarc.example.com"),
|
|
1598
|
+
type: z4.enum(["A", "AAAA", "CNAME", "MX", "NS", "TXT", "SOA", "CAA", "SRV", "PTR"]).optional().describe("DNS question type. Omit to check all supported types.")
|
|
1515
1599
|
},
|
|
1516
1600
|
(c, a, request) => c.dns(a.domain, { ...request, type: a.type })
|
|
1517
1601
|
);
|
|
1518
1602
|
tool(
|
|
1519
1603
|
"mx",
|
|
1520
1604
|
"MX records for a domain.",
|
|
1521
|
-
{ domain:
|
|
1605
|
+
{ domain: z4.string().describe("Domain name") },
|
|
1522
1606
|
(c, a, request) => c.mx(a.domain, request)
|
|
1523
1607
|
);
|
|
1524
1608
|
tool(
|
|
1525
1609
|
"useragent",
|
|
1526
1610
|
"Parse a User-Agent string: browser, OS, device, bot detection.",
|
|
1527
|
-
{ ua:
|
|
1611
|
+
{ ua: z4.string().describe("The User-Agent string to parse"), deep },
|
|
1528
1612
|
(c, a, request) => c.useragent(a.ua, { ...request, deep: a.deep })
|
|
1529
1613
|
);
|
|
1530
1614
|
tool(
|
|
1531
1615
|
"vehicle",
|
|
1532
1616
|
"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.",
|
|
1533
|
-
{ vin:
|
|
1617
|
+
{ vin: z4.string().describe("The VIN as you have it. Spaces and punctuation fold out"), deep },
|
|
1534
1618
|
(c, a, request) => c.vehicle(a.vin, { ...request, deep: a.deep })
|
|
1535
1619
|
);
|
|
1536
1620
|
tool(
|
|
1537
1621
|
"vin",
|
|
1538
1622
|
"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.",
|
|
1539
|
-
{ vin:
|
|
1623
|
+
{ vin: z4.string().describe("The VIN as you have it. Spaces and punctuation fold out"), deep },
|
|
1540
1624
|
(c, a, request) => c.vin(a.vin, { ...request, deep: a.deep })
|
|
1541
1625
|
);
|
|
1542
1626
|
tool(
|
|
1543
1627
|
"tariff",
|
|
1544
|
-
"Look up a tariff code, description, lineage
|
|
1628
|
+
"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.",
|
|
1545
1629
|
{
|
|
1546
|
-
code:
|
|
1547
|
-
origin: iso2("country
|
|
1630
|
+
code: z4.string().describe("US HTS code: 4, 6, 8 or 10 ASCII digits, dots and whitespace optional, e.g. 8471.30.01.00"),
|
|
1631
|
+
origin: iso2("country where the goods originate, not the shipping country; only read with deep").optional(),
|
|
1632
|
+
edition: tariffEdition,
|
|
1633
|
+
date: tariffDate,
|
|
1548
1634
|
deep
|
|
1549
1635
|
},
|
|
1550
|
-
(c, a, request) => c.tariff(a.code, { ...request, deep: a.deep, origin: a.origin })
|
|
1636
|
+
(c, a, request) => c.tariff(a.code, { ...request, deep: a.deep, origin: a.origin, edition: a.edition, date: a.date })
|
|
1551
1637
|
);
|
|
1552
1638
|
tool(
|
|
1553
1639
|
"tariff_search",
|
|
1554
|
-
"Search US tariff schedule descriptions by product. Returns up to 20 lines
|
|
1555
|
-
{ query:
|
|
1556
|
-
(c, a, request) => c.tariff.search(a.query, request)
|
|
1640
|
+
"Search US tariff schedule descriptions by product words. Returns up to 20 candidate lines with hts, description, general rate and parent lineage, plus the exact edition and answering date. Optional edition pins immutable source bytes. Optional date requires verified source coverage; combine only when that edition covers the date. Edition without date returns date null. Description search is not product classification.",
|
|
1641
|
+
{ query: z4.string().describe("Product words, e.g. sunglasses, laptop, coffee"), edition: tariffEdition, date: tariffDate },
|
|
1642
|
+
(c, a, request) => c.tariff.search(a.query, { ...request, edition: a.edition, date: a.date })
|
|
1557
1643
|
);
|
|
1558
1644
|
tool(
|
|
1559
1645
|
"industry",
|
|
1560
1646
|
"Look up a US NAICS 2022 code, title and parent hierarchy. Deep adds definition, children and exclusions on paid plans.",
|
|
1561
|
-
{ code:
|
|
1647
|
+
{ code: z4.string().describe("NAICS code, e.g. 541511 or sector range 31-33"), deep: deep.describe("Include the complete detail bag on a paid plan.") },
|
|
1562
1648
|
(c, a, request) => c.industry(a.code, { ...request, deep: a.deep })
|
|
1563
1649
|
);
|
|
1564
1650
|
tool(
|
|
1565
1651
|
"industry_search",
|
|
1566
1652
|
"Search US NAICS 2022 titles and activities. Matching text and corrections stay with the result. Deep adds definition, children and exclusions inside each result on paid plans.",
|
|
1567
1653
|
{
|
|
1568
|
-
query:
|
|
1569
|
-
limit:
|
|
1654
|
+
query: z4.string().min(1).max(100).describe("Industry keywords, e.g. coffee shop"),
|
|
1655
|
+
limit: z4.number().int().min(1).max(50).optional().describe("Maximum results, 1-50. Default 10."),
|
|
1570
1656
|
deep: deep.describe("Include the complete detail bag on a paid plan.")
|
|
1571
1657
|
},
|
|
1572
1658
|
(c, a, request) => c.industry.search(a.query, { ...request, deep: a.deep, limit: a.limit })
|
|
@@ -1574,15 +1660,15 @@ function buildServer(key, transport, options = {}) {
|
|
|
1574
1660
|
tool(
|
|
1575
1661
|
"naics",
|
|
1576
1662
|
"Compatibility name for industry. Look up a US NAICS 2022 code, title and parent hierarchy. Deep adds definition, children and exclusions on paid plans.",
|
|
1577
|
-
{ code:
|
|
1663
|
+
{ code: z4.string().describe("NAICS code, e.g. 541511 or sector range 31-33"), deep: deep.describe("Include the complete detail bag on a paid plan.") },
|
|
1578
1664
|
(c, a, request) => c.industry(a.code, { ...request, deep: a.deep })
|
|
1579
1665
|
);
|
|
1580
1666
|
tool(
|
|
1581
1667
|
"naics_search",
|
|
1582
1668
|
"Compatibility name for industry_search. Search US NAICS 2022 titles and activities. Matching text and corrections stay with the result. Deep adds definition, children and exclusions inside each result on paid plans.",
|
|
1583
1669
|
{
|
|
1584
|
-
query:
|
|
1585
|
-
limit:
|
|
1670
|
+
query: z4.string().min(1).max(100).describe("Industry keywords, e.g. coffee shop"),
|
|
1671
|
+
limit: z4.number().int().min(1).max(50).optional().describe("Maximum results, 1-50. Default 10."),
|
|
1586
1672
|
deep: deep.describe("Include the complete detail bag on a paid plan.")
|
|
1587
1673
|
},
|
|
1588
1674
|
(c, a, request) => c.industry.search(a.query, { ...request, deep: a.deep, limit: a.limit })
|
|
@@ -1590,35 +1676,35 @@ function buildServer(key, transport, options = {}) {
|
|
|
1590
1676
|
tool(
|
|
1591
1677
|
"currency",
|
|
1592
1678
|
"Currency name, symbols and decimal places. Deep adds numeric code, plural name and using countries on every plan.",
|
|
1593
|
-
{ code:
|
|
1679
|
+
{ code: z4.string().describe("ISO 4217 code, e.g. USD"), deep: deep.describe("Include optional detail on every plan.") },
|
|
1594
1680
|
(c, a, request) => c.currency(a.code, { ...request, deep: a.deep })
|
|
1595
1681
|
);
|
|
1596
1682
|
tool(
|
|
1597
1683
|
"currency_rate",
|
|
1598
1684
|
"Reference exchange rate between two currencies. Pass date for a past business day, amount to convert.",
|
|
1599
1685
|
{
|
|
1600
|
-
base:
|
|
1601
|
-
quote:
|
|
1602
|
-
date:
|
|
1686
|
+
base: z4.string().describe("Base currency ISO 4217 code, e.g. USD"),
|
|
1687
|
+
quote: z4.string().describe("Quote currency ISO 4217 code, e.g. EUR"),
|
|
1688
|
+
date: z4.string().optional().describe(
|
|
1603
1689
|
"YYYY-MM-DD. Official rate for that business day. A weekend or holiday resolves to the last published day on or before it"
|
|
1604
1690
|
),
|
|
1605
|
-
amount:
|
|
1691
|
+
amount: z4.number().optional().describe("Appends amount and converted, rounded to the quote currency minor-unit digits")
|
|
1606
1692
|
},
|
|
1607
1693
|
(c, a, request) => c.currency.rate(a.base, a.quote, { ...request, date: a.date, amount: a.amount })
|
|
1608
1694
|
);
|
|
1609
1695
|
tool(
|
|
1610
1696
|
"language",
|
|
1611
1697
|
"Language names, script and writing direction. Deep adds ISO3 and country associations on every plan.",
|
|
1612
|
-
{ code:
|
|
1698
|
+
{ code: z4.string().describe("Language code, e.g. en, ja, gsw"), deep: deep.describe("Include optional detail on every plan.") },
|
|
1613
1699
|
(c, a, request) => c.language(a.code, { ...request, deep: a.deep })
|
|
1614
1700
|
);
|
|
1615
1701
|
tool(
|
|
1616
1702
|
"name",
|
|
1617
1703
|
"Parse a name into prefix, first, middle, last and suffix. Paid deep adds gender evidence, salutation, short and directory formats, and initials. Country scopes gender evidence. name_locale selects formatting rules. Junk returns valid false.",
|
|
1618
1704
|
{
|
|
1619
|
-
name:
|
|
1620
|
-
country:
|
|
1621
|
-
name_locale:
|
|
1705
|
+
name: z4.string().describe("The name to parse, e.g. Smith, John or BILLY OSHALL"),
|
|
1706
|
+
country: z4.string().optional().describe("ISO2 country context for gender, e.g. IT"),
|
|
1707
|
+
name_locale: z4.string().min(2).max(64).optional().describe("Name-formatting locale, e.g. en or ja. Defaults to en. Changes formatting only, not parsing or gender evidence."),
|
|
1622
1708
|
deep: deep.describe("Include the complete detail bag on a paid plan.")
|
|
1623
1709
|
},
|
|
1624
1710
|
(c, a, request) => c.name(a.name, { ...request, deep: a.deep, country: a.country, name_locale: a.name_locale })
|
|
@@ -1627,21 +1713,21 @@ function buildServer(key, transport, options = {}) {
|
|
|
1627
1713
|
"time",
|
|
1628
1714
|
"Current local time, Unix seconds, exact offset and DST. Use an IANA zone, both coordinates, or one explicit IP, city, country, airport, port or address selector. Omit all for UTC. Ambiguous or missing locations return null clock fields with location candidates; never choose a candidate for the user. to or targets converts one instant. Deep adds rule edition, wall-time resolution, standard/seasonal offsets and actual DST-season transitions on every plan.",
|
|
1629
1715
|
{
|
|
1630
|
-
timezone:
|
|
1716
|
+
timezone: z4.string().min(1).refine((zone) => !["zones", "help"].includes(zone.trim().toLowerCase()), { message: "Time source must be an IANA timezone ID. Use time_zones to list IDs." }).optional().describe("IANA timezone, e.g. America/New_York. Omit for UTC when all source selectors are absent"),
|
|
1631
1717
|
lat: lat.optional(),
|
|
1632
1718
|
lon: lon.optional(),
|
|
1633
|
-
ip:
|
|
1634
|
-
city:
|
|
1635
|
-
country:
|
|
1636
|
-
state:
|
|
1637
|
-
iata:
|
|
1638
|
-
icao:
|
|
1639
|
-
unlocode:
|
|
1640
|
-
address:
|
|
1641
|
-
at:
|
|
1642
|
-
disambiguation:
|
|
1643
|
-
targets:
|
|
1644
|
-
to:
|
|
1719
|
+
ip: z4.string().min(1).max(45).refine((value) => Boolean(value.trim()), { message: "Time source must not be empty." }).optional().describe("Explicit IPv4 or IPv6 input. Never use a hosted server IP as the user location."),
|
|
1720
|
+
city: z4.string().min(1).max(200).refine((value) => Boolean(value.trim()), { message: "Time source must not be empty." }).optional().describe("Exact city name or stable city_ identifier. Country and state can narrow candidates."),
|
|
1721
|
+
country: z4.string().regex(/^[A-Za-z]{2}$/).optional().describe("ISO2 country as the source, or context with city/address. Multiple country timezones remain candidates."),
|
|
1722
|
+
state: z4.string().min(1).max(6).optional().describe("State context with city/address and country, as a bare code or matching country-prefixed code."),
|
|
1723
|
+
iata: z4.string().regex(/^[A-Za-z]{3}$/).optional().describe("Three-letter IATA airport identifier."),
|
|
1724
|
+
icao: z4.string().regex(/^[A-Za-z]{4}$/).optional().describe("Four-letter ICAO airport identifier."),
|
|
1725
|
+
unlocode: z4.string().regex(/^[A-Za-z]{2} ?[A-Za-z2-9]{3}$/).optional().describe("UN/LOCODE port identifier. Results use the reviewed port reference, not every assigned UN/LOCODE."),
|
|
1726
|
+
address: z4.string().min(1).max(200).refine((value) => Boolean(value.trim()), { message: "Time source must not be empty." }).optional().describe("Full address with explicit country. Strict point matches are currently supported for US; ambiguity stays unresolved."),
|
|
1727
|
+
at: z4.string().min(1).optional().describe("ISO 8601 time, default now. With to or targets, a time without a UTC offset is source wall time. Otherwise it is UTC. Include an offset to disambiguate a repeated local time"),
|
|
1728
|
+
disambiguation: z4.enum(["compatible", "earlier", "later", "reject"]).optional().describe("For offsetless at with to or targets at a clock change. Default compatible chooses the earlier repeated time or advances a skipped time. earlier and later choose the respective instant. For user-entered appointments prefer reject: repeated times return ambiguous_time and skipped times nonexistent_time. Ask for an explicit offset or earlier/later choice. Deep resolution explains a successful choice. Explicit offsets select the instant directly."),
|
|
1729
|
+
targets: z4.array(z4.string().trim().min(1).max(64).refine((zone) => !zone.includes(","), { message: "Pass one timezone ID per target." })).min(1).max(10).optional().describe("Destination IANA IDs, preserving order and duplicates. Use instead of to. All targets share one instant. An unresolved or ambiguous source returns targets null."),
|
|
1730
|
+
to: z4.string().min(1).optional().describe("Destination IANA timezone, e.g. Asia/Tokyo. Returns to.at and to.unix at the same instant"),
|
|
1645
1731
|
deep: deep.describe("Include optional detail on every plan.")
|
|
1646
1732
|
},
|
|
1647
1733
|
(c, a, request) => a.lat !== void 0 && a.lon !== void 0 ? c.time.at(a.lat, a.lon, { ...request, deep: a.deep, at: a.at, to: a.to, targets: a.targets, disambiguation: a.disambiguation }) : c.time(a.timezone, { ...request, ip: a.ip, city: a.city, country: a.country, state: a.state, iata: a.iata, icao: a.icao, unlocode: a.unlocode, address: a.address, deep: a.deep, at: a.at, to: a.to, targets: a.targets, disambiguation: a.disambiguation }),
|
|
@@ -1657,16 +1743,16 @@ function buildServer(key, transport, options = {}) {
|
|
|
1657
1743
|
"time_zones",
|
|
1658
1744
|
"Search serving IANA timezone identifiers and their pinned rule edition. Filter by country, IANA area, exact offset, abbreviation or DST facts at one instant. Abbreviations return candidate identifiers and never choose a timezone. Empty timezones means no match. Details adds aligned rows and the evaluation instant. One pooled request.",
|
|
1659
1745
|
{
|
|
1660
|
-
query:
|
|
1661
|
-
country:
|
|
1662
|
-
area:
|
|
1663
|
-
offset:
|
|
1664
|
-
abbreviation:
|
|
1665
|
-
dst:
|
|
1666
|
-
observes_dst:
|
|
1667
|
-
at:
|
|
1668
|
-
details:
|
|
1669
|
-
sort:
|
|
1746
|
+
query: z4.string().trim().max(64).optional().describe("Identifier search, e.g. New York or Europe. Spaces and underscores match the same way."),
|
|
1747
|
+
country: z4.string().regex(/^[A-Za-z]{2}$/).optional().describe("ISO2 country association, e.g. US."),
|
|
1748
|
+
area: z4.string().min(1).max(64).optional().describe("IANA identifier prefix, e.g. America."),
|
|
1749
|
+
offset: z4.string().regex(/^[+-]\d{2}:\d{2}(?::\d{2})?$/).optional().describe("Exact UTC offset at the selected instant, e.g. +05:45 or +00:09:21."),
|
|
1750
|
+
abbreviation: z4.string().min(1).max(64).optional().describe("Timezone abbreviation to find candidates for, e.g. CST. Never infer a unique zone from an abbreviation."),
|
|
1751
|
+
dst: z4.boolean().optional().describe("Whether the rule DST flag is active at the selected instant. Includes negative seasonal adjustments."),
|
|
1752
|
+
observes_dst: z4.boolean().optional().describe("Whether a DST-flagged state occurs during the UTC calendar year containing at."),
|
|
1753
|
+
at: z4.string().min(1).optional().describe("ISO instant for all filters and detailed rows. Default now. Offsetless input means UTC."),
|
|
1754
|
+
details: z4.boolean().optional().describe("Include zones rows with country associations, area, offset, abbreviation and DST facts, plus the common evaluation instant."),
|
|
1755
|
+
sort: z4.enum(["timezone", "offset"]).optional().describe("Order by identifier (default) or actual UTC offset, then identifier.")
|
|
1670
1756
|
},
|
|
1671
1757
|
(c, a, request) => c.time.zones(a.query, { ...request, country: a.country, area: a.area, offset: a.offset, abbreviation: a.abbreviation, dst: a.dst, observes_dst: a.observes_dst, at: a.at, details: a.details, sort: a.sort })
|
|
1672
1758
|
);
|
|
@@ -1674,13 +1760,13 @@ function buildServer(key, transport, options = {}) {
|
|
|
1674
1760
|
"timezone",
|
|
1675
1761
|
"Compatibility tool; use time for new integrations. Look up a timezone from an IANA id or from lat and lon. Offset, DST, local time. Pass at for a specific instant. Pass to with another IANA id to convert a time between zones: the response appends at (wall time in the from zone) and to.at (the converted time). Open ocean answers the nautical Etc/GMT zone.",
|
|
1676
1762
|
{
|
|
1677
|
-
timezone:
|
|
1763
|
+
timezone: z4.string().min(1).optional().describe("IANA timezone id, e.g. America/New_York"),
|
|
1678
1764
|
lat: lat.optional(),
|
|
1679
1765
|
lon: lon.optional(),
|
|
1680
|
-
at:
|
|
1766
|
+
at: z4.string().optional().describe(
|
|
1681
1767
|
"ISO 8601 time, default now. With to and no UTC offset, reads as wall time in the from zone"
|
|
1682
1768
|
),
|
|
1683
|
-
to:
|
|
1769
|
+
to: z4.string().optional().describe("Convert: the other IANA zone, e.g. Asia/Tokyo. Requires timezone, not lat/lon")
|
|
1684
1770
|
},
|
|
1685
1771
|
(c, a, request) => {
|
|
1686
1772
|
if (a.lat != null && a.lon != null) {
|
|
@@ -1700,9 +1786,9 @@ function buildServer(key, transport, options = {}) {
|
|
|
1700
1786
|
"date",
|
|
1701
1787
|
"Parse a date to ISO date, validity and Unix midnight. Ambiguous numeric dates need format. to adds signed days between; omit date for UTC today. Deep adds calendar details on every plan.",
|
|
1702
1788
|
{
|
|
1703
|
-
date:
|
|
1704
|
-
format:
|
|
1705
|
-
to:
|
|
1789
|
+
date: z4.string().min(1).optional().describe("The date as you have it, any common format. Omit for today (UTC)"),
|
|
1790
|
+
format: z4.enum(["mdy", "dmy"]).optional().describe("Breaks the month-first / day-first tie on numeric dates like 03/04/2026"),
|
|
1791
|
+
to: z4.string().optional().describe("Another date. Appends to (normalized ISO) and days (signed days between)"),
|
|
1706
1792
|
deep: deep.describe("Include optional detail on every plan.")
|
|
1707
1793
|
},
|
|
1708
1794
|
(c, a, request) => {
|
|
@@ -1719,34 +1805,35 @@ function buildServer(key, transport, options = {}) {
|
|
|
1719
1805
|
"Public holidays and cultural observances for a country and year. Each row carries type: public or observance.",
|
|
1720
1806
|
{
|
|
1721
1807
|
country: iso2("country code"),
|
|
1722
|
-
year:
|
|
1808
|
+
year: z4.number().int().optional().describe("Year, default current")
|
|
1723
1809
|
},
|
|
1724
1810
|
(c, a, request) => c.holiday(a.country, { ...request, year: a.year })
|
|
1725
1811
|
);
|
|
1726
1812
|
tool(
|
|
1727
1813
|
"holiday_date",
|
|
1728
1814
|
"Whether a specific date is a holiday or observance in a country. holiday is null when it is not.",
|
|
1729
|
-
{ country: iso2("country code"), date:
|
|
1815
|
+
{ country: iso2("country code"), date: z4.string().describe("Date as YYYY-MM-DD") },
|
|
1730
1816
|
(c, a, request) => c.holiday.date(a.country, a.date, request)
|
|
1731
1817
|
);
|
|
1732
1818
|
tool(
|
|
1733
1819
|
"emoji",
|
|
1734
1820
|
"Resolve an emoji character, shortcode or name. Deep adds encoding, keywords and skin variants on every plan.",
|
|
1735
|
-
{ emoji:
|
|
1821
|
+
{ emoji: z4.string().describe("Emoji name or the character itself, e.g. rocket"), deep: deep.describe("Include optional detail on every plan.") },
|
|
1736
1822
|
(c, a, request) => c.emoji(a.emoji, { ...request, deep: a.deep })
|
|
1737
1823
|
);
|
|
1738
1824
|
tool(
|
|
1739
1825
|
"emoji_search",
|
|
1740
1826
|
"Search emoji by keyword. Deep adds encoding and skin-variant detail inside each result on every plan.",
|
|
1741
1827
|
{
|
|
1742
|
-
query:
|
|
1743
|
-
limit:
|
|
1828
|
+
query: z4.string().describe("Search keyword, e.g. fire"),
|
|
1829
|
+
limit: z4.number().int().min(1).max(50).optional().describe("Max results"),
|
|
1744
1830
|
deep: deep.describe("Include optional detail on every plan.")
|
|
1745
1831
|
},
|
|
1746
1832
|
(c, a, request) => c.emoji.search(a.query, { ...request, deep: a.deep, limit: a.limit })
|
|
1747
1833
|
);
|
|
1748
1834
|
registerDiscovery(server, operations, mode, API_VERSION);
|
|
1749
1835
|
registerPreflight(server, parse, transport);
|
|
1836
|
+
registerTasks(server, parse, transport);
|
|
1750
1837
|
return server;
|
|
1751
1838
|
}
|
|
1752
1839
|
|
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.9.0",
|
|
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.10.0",
|
|
54
54
|
"zod": "^4.0.0"
|
|
55
55
|
},
|
|
56
56
|
"devDependencies": {
|