@honua/mcp-server 0.1.1-beta.0 → 0.1.4-beta.0

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

@@ -1,41 +1,114 @@
 import type { HonuaClient } from "@honua/sdk-js";
 import { z } from "zod";
+/**
+ * `honua_query_features` — protocol-neutral feature read (#1005).
+ *
+ * Addresses a source by its neutral `<protocol>:<address>` reference, filters
+ * with the typed semantic filter / GeoJSON geometry / canonical temporal
+ * predicate, and executes through the SDK's canonical `Source.query()`, so the
+ * same call means the same thing against GeoServices, OGC API Features, STAC,
+ * WFS, and OData. The deprecated `serviceId` + `layerId` pair is still accepted.
+ */
 export declare const schema: z.ZodObject<{
-    serviceId: z.ZodString;
-    layerId: z.ZodNumber;
-    where: z.ZodOptional<z.ZodString>;
     outFields: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    geometry: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    geometryType: z.ZodOptional<z.ZodEnum<["esriGeometryPoint", "esriGeometryPolyline", "esriGeometryPolygon", "esriGeometryEnvelope", "esriGeometryMultipoint"]>>;
-    spatialRel: z.ZodOptional<z.ZodEnum<["intersects", "contains", "within"]>>;
-    orderBy: z.ZodOptional<z.ZodString>;
+    orderBy: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodObject<{
+        field: z.ZodString;
+        direction: z.ZodOptional<z.ZodEnum<["asc", "desc"]>>;
+    }, "strip", z.ZodTypeAny, {
+        field: string;
+        direction?: "asc" | "desc" | undefined;
+    }, {
+        field: string;
+        direction?: "asc" | "desc" | undefined;
+    }>, "many">, z.ZodString]>>;
     limit: z.ZodOptional<z.ZodNumber>;
     offset: z.ZodOptional<z.ZodNumber>;
     returnGeometry: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    geometryFormat: z.ZodOptional<z.ZodEnum<["geojson", "esri-json"]>>;
+    outSr: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    filter: z.ZodOptional<z.ZodType<import("../neutral/filter.js").FilterNode, z.ZodTypeDef, import("../neutral/filter.js").FilterNode>>;
+    where: z.ZodOptional<z.ZodString>;
+    bbox: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+    bboxSrid: z.ZodOptional<z.ZodNumber>;
+    geometry: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    geometryType: z.ZodOptional<z.ZodEnum<["esriGeometryPoint", "esriGeometryPolyline", "esriGeometryPolygon", "esriGeometryEnvelope", "esriGeometryMultipoint"]>>;
+    spatialRel: z.ZodOptional<z.ZodEnum<["intersects", "contains", "within", "crosses", "touches", "overlaps", "bbox-intersects"]>>;
+    temporal: z.ZodOptional<z.ZodObject<{
+        instant: z.ZodOptional<z.ZodString>;
+        start: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        end: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        field: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        field?: string | undefined;
+        instant?: string | undefined;
+        start?: string | null | undefined;
+        end?: string | null | undefined;
+    }, {
+        field?: string | undefined;
+        instant?: string | undefined;
+        start?: string | null | undefined;
+        end?: string | null | undefined;
+    }>>;
+    source: z.ZodOptional<z.ZodString>;
+    layout: z.ZodOptional<z.ZodEnum<["honua-facade", "ogc-api", "auto", "stac-api", "stac-static"]>>;
+    serviceId: z.ZodOptional<z.ZodString>;
+    layerId: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
-    serviceId: string;
-    layerId: number;
     returnGeometry: boolean;
-    where?: string | undefined;
+    filter?: import("../neutral/filter.js").FilterNode | undefined;
+    serviceId?: string | undefined;
     geometry?: Record<string, unknown> | undefined;
+    bbox?: number[] | undefined;
     geometryType?: "esriGeometryPoint" | "esriGeometryPolyline" | "esriGeometryPolygon" | "esriGeometryEnvelope" | "esriGeometryMultipoint" | undefined;
-    spatialRel?: "intersects" | "contains" | "within" | undefined;
-    outFields?: string[] | undefined;
-    orderBy?: string | undefined;
+    temporal?: {
+        field?: string | undefined;
+        instant?: string | undefined;
+        start?: string | null | undefined;
+        end?: string | null | undefined;
+    } | undefined;
+    layout?: "honua-facade" | "ogc-api" | "auto" | "stac-api" | "stac-static" | undefined;
+    layerId?: number | undefined;
+    source?: string | undefined;
+    orderBy?: string | {
+        field: string;
+        direction?: "asc" | "desc" | undefined;
+    }[] | undefined;
+    where?: string | undefined;
+    bboxSrid?: number | undefined;
+    spatialRel?: "intersects" | "contains" | "within" | "crosses" | "touches" | "overlaps" | "bbox-intersects" | undefined;
     limit?: number | undefined;
+    outFields?: string[] | undefined;
     offset?: number | undefined;
+    geometryFormat?: "geojson" | "esri-json" | undefined;
+    outSr?: string | number | undefined;
 }, {
-    serviceId: string;
-    layerId: number;
-    where?: string | undefined;
+    filter?: import("../neutral/filter.js").FilterNode | undefined;
+    serviceId?: string | undefined;
     geometry?: Record<string, unknown> | undefined;
+    bbox?: number[] | undefined;
     geometryType?: "esriGeometryPoint" | "esriGeometryPolyline" | "esriGeometryPolygon" | "esriGeometryEnvelope" | "esriGeometryMultipoint" | undefined;
-    spatialRel?: "intersects" | "contains" | "within" | undefined;
-    outFields?: string[] | undefined;
-    orderBy?: string | undefined;
+    temporal?: {
+        field?: string | undefined;
+        instant?: string | undefined;
+        start?: string | null | undefined;
+        end?: string | null | undefined;
+    } | undefined;
+    layout?: "honua-facade" | "ogc-api" | "auto" | "stac-api" | "stac-static" | undefined;
+    layerId?: number | undefined;
+    source?: string | undefined;
+    orderBy?: string | {
+        field: string;
+        direction?: "asc" | "desc" | undefined;
+    }[] | undefined;
+    where?: string | undefined;
+    bboxSrid?: number | undefined;
+    spatialRel?: "intersects" | "contains" | "within" | "crosses" | "touches" | "overlaps" | "bbox-intersects" | undefined;
     limit?: number | undefined;
+    outFields?: string[] | undefined;
     offset?: number | undefined;
     returnGeometry?: boolean | undefined;
+    geometryFormat?: "geojson" | "esri-json" | undefined;
+    outSr?: string | number | undefined;
 }>;
 export type Input = z.infer<typeof schema>;
 export declare function execute(client: HonuaClient, input: Input): Promise<{
@@ -43,5 +116,12 @@ export declare function execute(client: HonuaClient, input: Input): Promise<{
         type: "text";
         text: string;
     }>;
+} | {
+    structuredContent: Record<string, unknown>;
+    isError: true;
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
 }>;
 //# sourceMappingURL=query-features.d.ts.map

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;AAGxB,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkBjB,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;;;;;GA+B9D"}
+{"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"}

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

@@ -1,51 +1,44 @@
 import { z } from "zod";
-import { GEOMETRY_TYPES, clampLimit, jsonText, mapSpatialRel, resolveGeometryType } from "../helpers.js";
+import { jsonText } from "../helpers.js";
+import { withCapabilityHonesty } from "../neutral/errors.js";
+import { queryFilterFields, queryShapeFields, toQuery } from "../neutral/query.js";
+import { projectDegraded, projectFeatures } from "../neutral/result.js";
+import { resolveSource, sourceRefFields } from "../neutral/source-ref.js";
+/**
+ * `honua_query_features` — protocol-neutral feature read (#1005).
+ *
+ * Addresses a source by its neutral `<protocol>:<address>` reference, filters
+ * with the typed semantic filter / GeoJSON geometry / canonical temporal
+ * predicate, and executes through the SDK's canonical `Source.query()`, so the
+ * same call means the same thing against GeoServices, OGC API Features, STAC,
+ * WFS, and OData. The deprecated `serviceId` + `layerId` pair is still accepted.
+ */
 export const schema = z.object({
-    serviceId: z.string().describe("The feature service ID"),
-    layerId: z.number().int().nonnegative().describe("The layer ID within the service"),
-    where: z.string().optional().describe('SQL WHERE clause, e.g. "population > 50000"'),
-    outFields: z.array(z.string()).optional().describe("Fields to return; defaults to all"),
-    geometry: z.record(z.unknown()).optional().describe("Esri JSON geometry for spatial filter"),
-    geometryType: z
-        .enum(GEOMETRY_TYPES)
-        .optional()
-        .describe("Esri geometry type. If omitted, inferred from geometry when possible."),
-    spatialRel: z
-        .enum(["intersects", "contains", "within"])
-        .optional()
-        .describe("Spatial relationship (default: intersects)"),
-    orderBy: z.string().optional().describe('Sort order, e.g. "name ASC"'),
-    limit: z.number().int().positive().optional().describe("Max features to return (default 100, max 2000)"),
-    offset: z.number().int().nonnegative().optional().describe("Number of features to skip (for pagination)"),
-    returnGeometry: z.boolean().optional().default(false).describe("Include geometry in results (default: false)"),
+    ...sourceRefFields,
+    ...queryFilterFields,
+    ...queryShapeFields,
 });
 export async function execute(client, input) {
-    const response = await client.queryFeatures({
-        serviceId: input.serviceId,
-        layerId: input.layerId,
-        where: input.where,
-        // An empty array is a natural "no specific fields" from an agent, but Esri
-        // FeatureServer treats an empty outFields as "OBJECTID only". Coerce both
-        // missing and empty to "*" so all fields are returned.
-        outFields: input.outFields && input.outFields.length > 0 ? input.outFields : "*",
-        geometry: input.geometry,
-        geometryType: resolveGeometryType(input.geometry, input.geometryType),
-        spatialRel: mapSpatialRel(input.spatialRel),
-        orderByFields: input.orderBy,
-        resultRecordCount: clampLimit(input.limit),
-        resultOffset: input.offset,
-        returnGeometry: input.returnGeometry,
-    });
-    const features = response.features ?? [];
-    return jsonText({
-        returnedCount: features.length,
-        features: features.map((f) => ({
-            attributes: f.attributes,
-            ...(input.returnGeometry && f.geometry ? { geometry: f.geometry } : {}),
-        })),
-        exceededTransferLimit: response.exceededTransferLimit ?? false,
-        objectIdFieldName: response.objectIdFieldName ?? null,
-        geometryType: response.geometryType ?? null,
-        spatialReference: response.spatialReference ?? null,
+    return withCapabilityHonesty(async () => {
+        const resolved = resolveSource(client, input);
+        const query = toQuery(input, { protocol: resolved.descriptor.protocol });
+        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
+        // addressing gets the neutral encoding.
+        const geometryFormat = input.geometryFormat ?? (resolved.legacyAddressing ? "esri-json" : "geojson");
+        const returnGeometry = input.returnGeometry ?? false;
+        const degraded = projectDegraded(result.degraded);
+        return jsonText({
+            source: resolved.ref.ref,
+            protocol: resolved.descriptor.protocol,
+            returnedCount: result.features.length,
+            features: projectFeatures(result, { returnGeometry, geometryFormat }),
+            geometryFormat: returnGeometry ? geometryFormat : null,
+            exceededTransferLimit: result.exceededTransferLimit,
+            totalCount: result.totalCount ?? null,
+            fields: result.fields ?? null,
+            ...(degraded ? { degraded } : {}),
+        });
     });
 }

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

@@ -1,26 +1,87 @@
 import type { HonuaClient } from "@honua/sdk-js";
 import { z } from "zod";
+/**
+ * `honua_statistics` — protocol-neutral aggregation (#1005).
+ *
+ * Lowers onto the canonical `AggregationSpec`, which GeoServices serves with
+ * `outStatistics` and which OGC API Features (no server-side aggregation)
+ * serves client-side over the returned page with an explicit `degraded` reason.
+ * The reason is reported in the result rather than dropped, so a page-scoped
+ * aggregate is never mistaken for an authoritative one.
+ */
 export declare const schema: z.ZodObject<{
-    serviceId: z.ZodString;
-    layerId: z.ZodNumber;
-    statisticType: z.ZodEnum<["count", "sum", "avg", "min", "max", "stddev"]>;
+    statisticType: z.ZodEnum<["count", "sum", "avg", "min", "max", "stddev", "var"]>;
     onField: z.ZodString;
-    groupBy: z.ZodOptional<z.ZodString>;
+    groupBy: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodString]>>;
+    filter: z.ZodOptional<z.ZodType<import("../neutral/filter.js").FilterNode, z.ZodTypeDef, import("../neutral/filter.js").FilterNode>>;
     where: z.ZodOptional<z.ZodString>;
+    bbox: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+    bboxSrid: z.ZodOptional<z.ZodNumber>;
+    geometry: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    geometryType: z.ZodOptional<z.ZodEnum<["esriGeometryPoint", "esriGeometryPolyline", "esriGeometryPolygon", "esriGeometryEnvelope", "esriGeometryMultipoint"]>>;
+    spatialRel: z.ZodOptional<z.ZodEnum<["intersects", "contains", "within", "crosses", "touches", "overlaps", "bbox-intersects"]>>;
+    temporal: z.ZodOptional<z.ZodObject<{
+        instant: z.ZodOptional<z.ZodString>;
+        start: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        end: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        field: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        field?: string | undefined;
+        instant?: string | undefined;
+        start?: string | null | undefined;
+        end?: string | null | undefined;
+    }, {
+        field?: string | undefined;
+        instant?: string | undefined;
+        start?: string | null | undefined;
+        end?: string | null | undefined;
+    }>>;
+    source: z.ZodOptional<z.ZodString>;
+    layout: z.ZodOptional<z.ZodEnum<["honua-facade", "ogc-api", "auto", "stac-api", "stac-static"]>>;
+    serviceId: z.ZodOptional<z.ZodString>;
+    layerId: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
-    serviceId: string;
-    layerId: number;
-    statisticType: "count" | "sum" | "avg" | "min" | "max" | "stddev";
+    statisticType: "count" | "sum" | "avg" | "min" | "max" | "stddev" | "var";
     onField: string;
+    filter?: import("../neutral/filter.js").FilterNode | undefined;
+    serviceId?: string | undefined;
+    geometry?: Record<string, unknown> | undefined;
+    bbox?: number[] | undefined;
+    geometryType?: "esriGeometryPoint" | "esriGeometryPolyline" | "esriGeometryPolygon" | "esriGeometryEnvelope" | "esriGeometryMultipoint" | undefined;
+    temporal?: {
+        field?: string | undefined;
+        instant?: string | undefined;
+        start?: string | null | undefined;
+        end?: string | null | undefined;
+    } | undefined;
+    layout?: "honua-facade" | "ogc-api" | "auto" | "stac-api" | "stac-static" | undefined;
+    layerId?: number | undefined;
+    source?: string | undefined;
     where?: string | undefined;
-    groupBy?: string | undefined;
+    bboxSrid?: number | undefined;
+    spatialRel?: "intersects" | "contains" | "within" | "crosses" | "touches" | "overlaps" | "bbox-intersects" | undefined;
+    groupBy?: string | string[] | undefined;
 }, {
-    serviceId: string;
-    layerId: number;
-    statisticType: "count" | "sum" | "avg" | "min" | "max" | "stddev";
+    statisticType: "count" | "sum" | "avg" | "min" | "max" | "stddev" | "var";
     onField: string;
+    filter?: import("../neutral/filter.js").FilterNode | undefined;
+    serviceId?: string | undefined;
+    geometry?: Record<string, unknown> | undefined;
+    bbox?: number[] | undefined;
+    geometryType?: "esriGeometryPoint" | "esriGeometryPolyline" | "esriGeometryPolygon" | "esriGeometryEnvelope" | "esriGeometryMultipoint" | undefined;
+    temporal?: {
+        field?: string | undefined;
+        instant?: string | undefined;
+        start?: string | null | undefined;
+        end?: string | null | undefined;
+    } | undefined;
+    layout?: "honua-facade" | "ogc-api" | "auto" | "stac-api" | "stac-static" | undefined;
+    layerId?: number | undefined;
+    source?: string | undefined;
     where?: string | undefined;
-    groupBy?: string | undefined;
+    bboxSrid?: number | undefined;
+    spatialRel?: "intersects" | "contains" | "within" | "crosses" | "touches" | "overlaps" | "bbox-intersects" | undefined;
+    groupBy?: string | string[] | undefined;
 }>;
 export type Input = z.infer<typeof schema>;
 export declare function execute(client: HonuaClient, input: Input): Promise<{
@@ -28,5 +89,12 @@ export declare function execute(client: HonuaClient, input: Input): Promise<{
         type: "text";
         text: string;
     }>;
+} | {
+    structuredContent: Record<string, unknown>;
+    isError: true;
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
 }>;
 //# sourceMappingURL=statistics.d.ts.map

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;AACjD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;EAOjB,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;;;;;GAuB9D"}
+{"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"}

package/dist/src/tools/statistics.js

@@ -1,31 +1,64 @@
 import { z } from "zod";
 import { jsonText } from "../helpers.js";
+import { withCapabilityHonesty } from "../neutral/errors.js";
+import { queryFilterFields, toQuery } from "../neutral/query.js";
+import { projectDegraded } from "../neutral/result.js";
+import { isGeoServicesProtocol, resolveSource, sourceRefFields } from "../neutral/source-ref.js";
+/**
+ * `honua_statistics` — protocol-neutral aggregation (#1005).
+ *
+ * Lowers onto the canonical `AggregationSpec`, which GeoServices serves with
+ * `outStatistics` and which OGC API Features (no server-side aggregation)
+ * serves client-side over the returned page with an explicit `degraded` reason.
+ * The reason is reported in the result rather than dropped, so a page-scoped
+ * aggregate is never mistaken for an authoritative one.
+ */
 export const schema = z.object({
-    serviceId: z.string().describe("The feature service ID"),
-    layerId: z.number().int().nonnegative().describe("The layer ID within the service"),
-    statisticType: z.enum(["count", "sum", "avg", "min", "max", "stddev"]).describe("The aggregate function to compute"),
-    onField: z.string().describe("The field to compute the statistic on"),
-    groupBy: z.string().optional().describe("Field to group results by"),
-    where: z.string().optional().describe("SQL WHERE clause to filter features"),
+    ...sourceRefFields,
+    ...queryFilterFields,
+    statisticType: z
+        .enum(["count", "sum", "avg", "min", "max", "stddev", "var"])
+        .describe("The aggregate function to compute."),
+    onField: z.string().describe("The field to compute the statistic on."),
+    groupBy: z
+        .union([z.array(z.string()), z.string()])
+        .optional()
+        .describe("Field(s) to group results by."),
 });
+function normalizeGroupBy(groupBy) {
+    if (groupBy === undefined)
+        return undefined;
+    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) {
-    const outStatisticFieldName = `${input.statisticType}_${input.onField}`;
-    const response = await client.queryFeatures({
-        serviceId: input.serviceId,
-        layerId: input.layerId,
-        where: input.where ?? "1=1",
-        outStatistics: [
-            {
-                statisticType: input.statisticType,
-                onStatisticField: input.onField,
-                outStatisticFieldName,
+    return withCapabilityHonesty(async () => {
+        const resolved = resolveSource(client, input);
+        const base = toQuery(input, { protocol: resolved.descriptor.protocol, paginate: false });
+        // 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"
+        // contract true on Esri endpoints.
+        if (isGeoServicesProtocol(resolved.descriptor.protocol) && base.filter === undefined && base.where === undefined) {
+            base.where = "1=1";
+        }
+        const groupBy = normalizeGroupBy(input.groupBy);
+        const alias = `${input.statisticType}_${input.onField}`;
+        const result = await resolved.source.queryAggregate({
+            ...base,
+            returnGeometry: false,
+            aggregation: {
+                ...(groupBy ? { groupBy } : {}),
+                metrics: [{ fn: input.statisticType, field: input.onField, alias }],
             },
-        ],
-        groupByFieldsForStatistics: input.groupBy,
-        returnGeometry: false,
-    });
-    const features = response.features ?? [];
-    return jsonText({
-        statistics: features.map((f) => ({ attributes: f.attributes })),
+        });
+        const degraded = projectDegraded(result.degraded);
+        return jsonText({
+            source: resolved.ref.ref,
+            protocol: resolved.descriptor.protocol,
+            statistic: alias,
+            statistics: (result.aggregateRows ?? []).map((attributes) => ({ attributes })),
+            ...(degraded ? { degraded } : {}),
+        });
     });
 }

package/package.json

@@ -1,7 +1,25 @@
 {
   "name": "@honua/mcp-server",
-  "version": "0.1.1-beta.0",
-  "description": "MCP server for Honua geospatial feature services",
+  "version": "0.1.4-beta.0",
+  "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",
+  "homepage": "https://honua-io.github.io/honua-sdk-js/",
+  "bugs": {
+    "url": "https://github.com/honua-io/honua-sdk-js/issues"
+  },
+  "keywords": [
+    "gis",
+    "geospatial",
+    "maplibre",
+    "typescript",
+    "mcp",
+    "model-context-protocol",
+    "ai-agent",
+    "arcgis",
+    "ogc-api",
+    "feature-service"
+  ],
   "type": "module",
   "bin": {
     "honua-mcp": "dist/src/index.js",
@@ -23,7 +41,7 @@
     "./package.json": "./package.json"
   },
   "scripts": {
-    "clean": "rm -rf dist coverage",
+    "clean": "node scripts/clean-output.mjs",
     "build": "npm run clean --silent && tsc -p tsconfig.json",
     "prepack": "npm run build --silent",
     "typecheck": "tsc --noEmit",
@@ -32,13 +50,16 @@
     "test:coverage": "vitest run --coverage",
     "certify": "npm run build --silent && node dist/src/certification/cli.js",
     "certify:standalone": "npm run build --silent && node dist/src/certification/cli.js --target standalone",
+    "certify:standalone-ogc": "npm run build --silent && node dist/src/certification/cli.js --target standalone-ogc",
     "test:certification:nl-map-control": "vitest run test/certification/nl-map-control.test.ts",
     "test:certification": "npm run build --silent && vitest run test/certification && node dist/src/certification/cli.js",
     "test:certification:artifact": "npm run build --silent && node dist/src/certification/cli.js --artifact-only",
     "test:certification:standalone": "npm run build --silent && node dist/src/certification/cli.js --target standalone",
+    "test:certification:standalone-ogc": "npm run build --silent && node dist/src/certification/cli.js --target standalone-ogc",
     "eval": "npm run build --silent && node dist/src/eval/cli.js",
     "eval:offline": "npm run build --silent && node dist/src/eval/cli.js --offline",
     "eval:standalone": "npm run build --silent && node dist/src/eval/cli.js --corpus standalone --offline",
+    "eval:ogc": "npm run build --silent && node dist/src/eval/cli.js --corpus ogc --offline",
     "eval:live": "npm run build --silent && node dist/src/eval/cli.js --corpus operator --artifact-only",
     "leaderboard": "node scripts/render-leaderboard.mjs",
     "test:eval": "npm run build --silent && vitest run test/eval && node dist/src/eval/cli.js --offline",
@@ -57,10 +78,12 @@
     "zod": "^3.24.0"
   },
   "overrides": {
-    "hono": "^4.12.21"
+    "hono": "^4.12.27",
+    "@hono/node-server": "^2.0.5",
+    "fast-uri": "^3.1.3"
   },
   "peerDependencies": {
-    "@honua/sdk-js": "^0.1.1-beta.0"
+    "@honua/sdk-js": "^0.1.4-beta.0"
   },
   "devDependencies": {
     "@biomejs/biome": "1.9.4",
@@ -73,10 +96,11 @@
   "files": [
     "dist/src",
     "certification/geospatial-mcp-schemas",
-    "README.md"
+    "README.md",
+    "LICENSE"
   ],
   "engines": {
-    "node": ">=20.0.0"
+    "node": ">=20.19.0"
   },
   "repository": {
     "type": "git",