@honua/mcp-server 0.1.13 → 0.1.14

package/README.md

@@ -260,7 +260,7 @@ Embedding the server in your own Node.js host needs the packages as local
 dependencies of that host project:
 
 ```bash
-npm install @honua/mcp-server @honua/sdk-js
+npm install @honua/mcp-server@0.1.13 @honua/sdk-js@0.1.13
 ```
 
 The map runtime, model callback, approval verifier, receipt signer, and
@@ -346,6 +346,7 @@ cd honua-sdk-js
 npm ci
 ```
 
+<!-- doc-run: checkout -->
 ```bash
 npm run build   # the SDK that mcp/ links to; takes a few minutes
 cd mcp
@@ -354,6 +355,7 @@ npm ci
 
 From `mcp/`:
 
+<!-- doc-run: checkout=mcp -->
 ```bash
 # Run the certifier against the offline fixture backend and write artifacts:
 npm run certify
@@ -384,6 +386,7 @@ skip-with-reason. Fixture-backed and deterministic — no network — as long as
 instead (the scheduled live variant). Unset it if you exported it for `honua-mcp`
 above:
 
+<!-- doc-run: checkout=mcp -->
 ```bash
 unset HONUA_BASE_URL
 npm run certify:standalone            # platform-free cert (plain FeatureServer fixture)
@@ -406,6 +409,7 @@ in `config/live-conformance-endpoints.v1.json`). Nothing Esri exists there: the
 GeoServices entry points all reject, so a tool that still secretly required
 `serviceId`/`layerId` fails loudly instead of passing by accident.
 
+<!-- doc-run: checkout=mcp -->
 ```bash
 npm run certify:standalone-ogc            # non-GeoServices cert (OGC API Features fixture)
 npm run test:certification:standalone-ogc # CI gate variant
@@ -521,6 +525,7 @@ honua-io/honua-server#1956.)
   dependencies); keys come from the environment and are never hardcoded. Set
   `HONUA_MCP_REMOTE_URL` to drive a live remote `/mcp` instead of the fixture.
 
+<!-- doc-run: checkout=mcp -->
 ```bash
 npm run eval            # run the eval (live models join if their keys are set)
 npm run eval:offline    # force the deterministic control + fixture surface
@@ -546,6 +551,7 @@ guards. Because the fixture replays real recorded data, a wrong number or a
 hallucinated place name fails. The grading taxonomy is documented in
 [`evals/README.md`](evals/README.md).
 
+<!-- doc-run: checkout=mcp -->
 ```bash
 npm run eval:standalone       # deterministic control over the census fixture (offline)
 ```
@@ -564,6 +570,7 @@ an extent that came from the declared collection extent must say so, and a CQL2
 spatial predicate the endpoint does not publish must come back as a structured
 capability refusal — never as an empty result set.
 
+<!-- doc-run: checkout=mcp -->
 ```bash
 npm run eval:ogc              # deterministic control over the OGC API Features fixture (offline)
 ```

package/dist/src/index.js

@@ -172,10 +172,10 @@ export function createServer(client, options = {}) {
         registerNlMapControlMcpTools(server, options.nlMapControl);
     }
     server.tool("honua_describe_layer", "Describe a source: its protocol, the capabilities it actually supports, field schema, geometry type, and extent. Address it with `source` (from honua_list_sources); the serviceId/layerId pair is deprecated but still accepted.", describeLayer.schema.shape, async (args) => describeLayer.execute(client, describeLayer.schema.parse(args)));
-    server.tool("honua_query_features", "Query features from any supported protocol. Address the source with `source`; filter with the typed protocol-neutral `filter`, a GeoJSON `geometry` or `bbox` plus `spatialRel`, and `temporal`. returnGeometry defaults to false to save tokens. A construct the backing protocol cannot express returns a structured capability error, never a silently empty result.", queryFeatures.schema.shape, async (args) => queryFeatures.execute(client, queryFeatures.schema.parse(args)));
-    server.tool("honua_count_features", "Count features matching a filter without returning data. Use before querying to check cardinality.", countFeatures.schema.shape, async (args) => countFeatures.execute(client, countFeatures.schema.parse(args)));
-    server.tool("honua_get_extent", "Get the spatial bounding box of features matching a filter.", getExtent.schema.shape, async (args) => getExtent.execute(client, getExtent.schema.parse(args)));
-    server.tool("honua_statistics", "Compute aggregate statistics (count, sum, avg, min, max, stddev, var) on a field, optionally grouped. Protocols without server-side aggregation answer client-side and report the degradation.", statistics.schema.shape, async (args) => statistics.execute(client, statistics.schema.parse(args)));
+    server.tool("honua_query_features", "Query features from any supported protocol. Address the source with `source`; filter with the typed protocol-neutral `filter`, a GeoJSON `geometry` or `bbox` plus `spatialRel`, and `temporal`. returnGeometry defaults to false to save tokens. A construct the backing protocol cannot express returns a structured capability error, never a silently empty result.", queryFeatures.schema.shape, async (args, extra) => queryFeatures.execute(client, queryFeatures.schema.parse(args), extra?.signal));
+    server.tool("honua_count_features", "Count features matching a filter without returning data. Use before querying to check cardinality.", countFeatures.schema.shape, async (args, extra) => countFeatures.execute(client, countFeatures.schema.parse(args), extra?.signal));
+    server.tool("honua_get_extent", "Get the spatial bounding box of features matching a filter.", getExtent.schema.shape, async (args, extra) => getExtent.execute(client, getExtent.schema.parse(args), extra?.signal));
+    server.tool("honua_statistics", "Compute aggregate statistics (count, sum, avg, min, max, stddev, var) on a field, optionally grouped. Protocols without server-side aggregation answer client-side and report the degradation.", statistics.schema.shape, async (args, extra) => statistics.execute(client, statistics.schema.parse(args), extra?.signal));
     server.tool("honua_explain_capability_gap", "Explain whether a source/protocol supports a capability and suggest a safe fallback when it does not.", explainCapabilityGap.schema.shape, async (args) => explainCapabilityGap.execute(client, explainCapabilityGap.schema.parse(args)));
     server.tool("honua_get_style", "Resolve a style from a server's OGC API – Styles surface. Pass styleId for the canonical StyleRef (style_id, title, encodings incl. inlined MapLibre); omit it to list available styles. On a plain FeatureServer with no styling surface, reports a structured 'not available on this target' result.", getStyle.schema.shape, async (args) => getStyle.execute(client, getStyle.schema.parse(args)));
     server.tool("honua_apply_style_preset", "Resolve a style preset and its MapLibre stylesheet for client-side application. Read-only: returns the stylesheet to apply locally; it does not mutate server state. Degrades gracefully on a target with no styling surface.", applyStylePreset.schema.shape, async (args) => applyStylePreset.execute(client, applyStylePreset.schema.parse(args)));

package/dist/src/neutral/result.d.ts

@@ -16,9 +16,9 @@ export type GeometryFormat = "geojson" | "esri-json";
 export declare function projectGeometry(geometry: Record<string, unknown> | null | undefined, format: GeometryFormat): Record<string, unknown> | null;
 /** Normalize `Result.degraded` for tool output; `undefined` when nothing degraded. */
 export declare function projectDegraded(degraded: readonly DegradedReason[] | undefined): {
-    capability: import("@honua/sdk-js/contract").Capability;
+    capability: import("@honua/sdk-js").Capability;
     reason: string;
-    protocol: import("@honua/sdk-js/contract").Protocol | null;
+    protocol: import("@honua/sdk-js").Protocol | null;
     sourceId: string | null;
 }[] | undefined;
 export interface ProjectFeaturesOptions {

package/dist/src/neutral/result.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"result.d.ts","sourceRoot":"","sources":["../../../src/neutral/result.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAGrE;;;;;;;;;;;GAWG;AAEH,MAAM,MAAM,cAAc,GAAG,SAAS,GAAG,WAAW,CAAC;AAMrD,gEAAgE;AAChE,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,GAAG,SAAS,EACpD,MAAM,EAAE,cAAc,GACrB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAMhC;AAED,sFAAsF;AACtF,wBAAgB,eAAe,CAAC,QAAQ,EAAE,SAAS,cAAc,EAAE,GAAG,SAAS;;;;;gBAQ9E;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC;IACjC,QAAQ,CAAC,cAAc,EAAE,cAAc,CAAC;CACzC;AAED,wEAAwE;AACxE,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,sBAAsB;;;IAU9E"}
+{"version":3,"file":"result.d.ts","sourceRoot":"","sources":["../../../src/neutral/result.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAGrE;;;;;;;;;;;GAWG;AAEH,MAAM,MAAM,cAAc,GAAG,SAAS,GAAG,WAAW,CAAC;AAMrD,gEAAgE;AAChE,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,GAAG,SAAS,EACpD,MAAM,EAAE,cAAc,GACrB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAWhC;AAED,sFAAsF;AACtF,wBAAgB,eAAe,CAAC,QAAQ,EAAE,SAAS,cAAc,EAAE,GAAG,SAAS;;;;;gBAQ9E;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC;IACjC,QAAQ,CAAC,cAAc,EAAE,cAAc,CAAC;CACzC;AAED,wEAAwE;AACxE,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,sBAAsB;;;IAU9E"}

package/dist/src/neutral/result.js

@@ -1,13 +1,20 @@
-import { esriToGeoJson } from "@honua/sdk-js/geometry";
+import { HonuaCapabilityNotSupportedError } from "@honua/sdk-js";
+import { esriToGeoJson, geoJsonToEsri } from "@honua/sdk-js/geometry";
 function looksGeoJson(geometry) {
-    return typeof geometry.type === "string" && "coordinates" in geometry;
+    return typeof geometry.type === "string" && ("coordinates" in geometry || geometry.type === "GeometryCollection");
 }
 /** Re-encode one feature geometry into the requested format. */
 export function projectGeometry(geometry, format) {
     if (!geometry)
         return null;
-    if (format === "esri-json")
-        return geometry;
+    if (format === "esri-json") {
+        if (!looksGeoJson(geometry))
+            return geometry;
+        const converted = geoJsonToEsri(geometry);
+        if (!converted)
+            throw new HonuaCapabilityNotSupportedError("geometryFormat.esri-json", "geometry-projection");
+        return converted;
+    }
     if (looksGeoJson(geometry))
         return geometry;
     const converted = esriToGeoJson(geometry);

package/dist/src/tools/count-features.d.ts

@@ -89,7 +89,7 @@ interface CountOutcome {
 }
 /** Resolve a feature count through the canonical `Source` surface. */
 export declare function countThroughSource(source: CapabilityAwareSource, query: Query, protocol: string, sourceId: string): Promise<CountOutcome>;
-export declare function execute(client: HonuaClient, input: Input): Promise<{
+export declare function execute(client: HonuaClient, input: Input, signal?: AbortSignal): Promise<{
     content: Array<{
         type: "text";
         text: string;

package/dist/src/tools/count-features.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"count-features.d.ts","sourceRoot":"","sources":["../../../src/tools/count-features.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAEjD,OAAO,KAAK,EAAE,qBAAqB,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAC;AAC3E,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAGvD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGjB,CAAC;AAEH,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,MAAM,CAAC,CAAC;AAE3C,UAAU,YAAY;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,aAAa,GAAG,YAAY,CAAC;IACvC,QAAQ,EAAE,UAAU,CAAC,OAAO,eAAe,CAAC,CAAC;CAC9C;AAED,sEAAsE;AACtE,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,qBAAqB,EAC7B,KAAK,EAAE,KAAK,EACZ,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,YAAY,CAAC,CAevB;AAED,wBAAsB,OAAO,CAAC,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,KAAK;;;;;;;;;;;;GAmB9D"}
+{"version":3,"file":"count-features.d.ts","sourceRoot":"","sources":["../../../src/tools/count-features.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAEjD,OAAO,KAAK,EAAE,qBAAqB,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAC;AAC3E,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAGvD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGjB,CAAC;AAEH,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,MAAM,CAAC,CAAC;AAE3C,UAAU,YAAY;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,aAAa,GAAG,YAAY,CAAC;IACvC,QAAQ,EAAE,UAAU,CAAC,OAAO,eAAe,CAAC,CAAC;CAC9C;AAED,sEAAsE;AACtE,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,qBAAqB,EAC7B,KAAK,EAAE,KAAK,EACZ,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,YAAY,CAAC,CAevB;AAED,wBAAsB,OAAO,CAAC,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,CAAC,EAAE,WAAW;;;;;;;;;;;;GAoBpF"}

package/dist/src/tools/count-features.js

@@ -38,10 +38,11 @@ export async function countThroughSource(source, query, protocol, sourceId) {
     }
     throw new HonuaCapabilityNotSupportedError("count", protocol, sourceId);
 }
-export async function execute(client, input) {
+export async function execute(client, input, signal) {
     return withCapabilityHonesty(async () => {
         const resolved = resolveSource(client, input);
         const query = toQuery(input, { protocol: resolved.descriptor.protocol, paginate: false });
+        query.signal = signal;
         const outcome = await countThroughSource(resolved.source, query, resolved.descriptor.protocol, resolved.descriptor.id);
         return jsonText({
             source: resolved.ref.ref,

package/dist/src/tools/get-extent.d.ts

@@ -74,7 +74,7 @@ export declare const schema: z.ZodObject<{
     spatialRel?: "intersects" | "contains" | "within" | "crosses" | "touches" | "overlaps" | "bbox-intersects" | undefined;
 }>;
 export type Input = z.infer<typeof schema>;
-export declare function execute(client: HonuaClient, input: Input): Promise<{
+export declare function execute(client: HonuaClient, input: Input, signal?: AbortSignal): Promise<{
     content: Array<{
         type: "text";
         text: string;

package/dist/src/tools/get-extent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-extent.d.ts","sourceRoot":"","sources":["../../../src/tools/get-extent.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB;;;;;;;GAOG;AACH,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGjB,CAAC;AAEH,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,MAAM,CAAC,CAAC;AAE3C,wBAAsB,OAAO,CAAC,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,KAAK;;;;;;;;;;;;GAgB9D"}
+{"version":3,"file":"get-extent.d.ts","sourceRoot":"","sources":["../../../src/tools/get-extent.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB;;;;;;;GAOG;AACH,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGjB,CAAC;AAEH,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,MAAM,CAAC,CAAC;AAE3C,wBAAsB,OAAO,CAAC,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,CAAC,EAAE,WAAW;;;;;;;;;;;;GAiBpF"}

package/dist/src/tools/get-extent.js

@@ -15,10 +15,11 @@ export const schema = z.object({
     ...sourceRefFields,
     ...queryFilterFields,
 });
-export async function execute(client, input) {
+export async function execute(client, input, signal) {
     return withCapabilityHonesty(async () => {
         const resolved = resolveSource(client, input);
         const query = toQuery(input, { protocol: resolved.descriptor.protocol, paginate: false });
+        query.signal = signal;
         const { extent, count } = await resolved.source.queryExtent(query);
         return jsonText({
             source: resolved.ref.ref,

package/dist/src/tools/query-features.d.ts

@@ -111,7 +111,7 @@ export declare const schema: z.ZodObject<{
     outSr?: string | number | undefined;
 }>;
 export type Input = z.infer<typeof schema>;
-export declare function execute(client: HonuaClient, input: Input): Promise<{
+export declare function execute(client: HonuaClient, input: Input, signal?: AbortSignal): Promise<{
     content: Array<{
         type: "text";
         text: string;

package/dist/src/tools/query-features.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"query-features.d.ts","sourceRoot":"","sources":["../../../src/tools/query-features.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB;;;;;;;;GAQG;AACH,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIjB,CAAC;AAEH,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,MAAM,CAAC,CAAC;AAE3C,wBAAsB,OAAO,CAAC,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,KAAK;;;;;;;;;;;;GAyB9D"}
+{"version":3,"file":"query-features.d.ts","sourceRoot":"","sources":["../../../src/tools/query-features.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB;;;;;;;;GAQG;AACH,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIjB,CAAC;AAEH,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,MAAM,CAAC,CAAC;AAE3C,wBAAsB,OAAO,CAAC,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,CAAC,EAAE,WAAW;;;;;;;;;;;;GA0BpF"}

package/dist/src/tools/query-features.js

@@ -18,10 +18,11 @@ export const schema = z.object({
     ...queryFilterFields,
     ...queryShapeFields,
 });
-export async function execute(client, input) {
+export async function execute(client, input, signal) {
     return withCapabilityHonesty(async () => {
         const resolved = resolveSource(client, input);
         const query = toQuery(input, { protocol: resolved.descriptor.protocol });
+        query.signal = signal;
         const result = await resolved.source.query(query);
         // Legacy addressing keeps legacy output: a client that still sends
         // serviceId/layerId also still expects Esri-JSON geometry. Neutral

package/dist/src/tools/statistics.d.ts

@@ -84,7 +84,7 @@ export declare const schema: z.ZodObject<{
     groupBy?: string | string[] | undefined;
 }>;
 export type Input = z.infer<typeof schema>;
-export declare function execute(client: HonuaClient, input: Input): Promise<{
+export declare function execute(client: HonuaClient, input: Input, signal?: AbortSignal): Promise<{
     content: Array<{
         type: "text";
         text: string;

package/dist/src/tools/statistics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"statistics.d.ts","sourceRoot":"","sources":["../../../src/tools/statistics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAEjD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB;;;;;;;;GAQG;AACH,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWjB,CAAC;AAEH,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,MAAM,CAAC,CAAC;AAQ3C,wBAAsB,OAAO,CAAC,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,KAAK;;;;;;;;;;;;GAgC9D"}
+{"version":3,"file":"statistics.d.ts","sourceRoot":"","sources":["../../../src/tools/statistics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAEjD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB;;;;;;;;GAQG;AACH,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWjB,CAAC;AAEH,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,MAAM,CAAC,CAAC;AAQ3C,wBAAsB,OAAO,CAAC,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,CAAC,EAAE,WAAW;;;;;;;;;;;;GAiCpF"}

package/dist/src/tools/statistics.js

@@ -31,10 +31,11 @@ function normalizeGroupBy(groupBy) {
     const fields = (Array.isArray(groupBy) ? groupBy : groupBy.split(",")).map((f) => f.trim()).filter(Boolean);
     return fields.length > 0 ? fields : undefined;
 }
-export async function execute(client, input) {
+export async function execute(client, input, signal) {
     return withCapabilityHonesty(async () => {
         const resolved = resolveSource(client, input);
         const base = toQuery(input, { protocol: resolved.descriptor.protocol, paginate: false });
+        base.signal = signal;
         // GeoServices rejects an `outStatistics` query that carries no `where`;
         // every other protocol treats "no filter" as "all records". Supplying the
         // tautology keeps the neutral "omit the filter ⇒ aggregate everything"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@honua/mcp-server",
-  "version": "0.1.13",
+  "version": "0.1.14",
   "description": "Platform-free MCP server for geospatial services: expose discovery, query, and analysis over any public ArcGIS/Esri FeatureServer or OGC API endpoint to any MCP client, with no platform lock-in",
   "license": "Apache-2.0",
   "author": "Honua",
@@ -89,7 +89,7 @@
     "qs": "^6.16.0"
   },
   "peerDependencies": {
-    "@honua/sdk-js": "^0.1.13"
+    "@honua/sdk-js": "^0.1.14"
   },
   "devDependencies": {
     "@biomejs/biome": "1.9.4",