@honua/mcp-server 0.0.10-alpha.0 → 0.1.0-beta.0

package/dist/src/resources/styles.js

@@ -0,0 +1,76 @@
+import { CapabilityUnavailableError, capabilityUnavailablePayload } from "../capability.js";
+import { STYLE_SURFACE, listStyles, resolveStyleRef } from "../styles.js";
+const STYLE_GUIDANCE = "This target is a plain FeatureServer/OGC endpoint with no OGC API - Styles surface. " +
+    "Build a MapLibre style client-side, or point honua-mcp at a Honua deployment for managed styles.";
+/** URI for the styles catalog resource (`honua://styles`). */
+export const uri = "honua://styles";
+/** URI template for a single style resource (`honua://styles/{styleId}`). */
+export const uriTemplate = "honua://styles/{styleId}";
+/**
+ * Read the styles catalog: the list of styles available on the server, each
+ * with its stable styleId, title, and canonical URI (`honua://styles/{id}`).
+ */
+export async function readCatalog(client) {
+    let list;
+    try {
+        list = await listStyles(client);
+    }
+    catch (err) {
+        if (err instanceof CapabilityUnavailableError) {
+            return unavailableContents(uri, err.reason);
+        }
+        throw err;
+    }
+    const styles = list.styles.map((entry) => ({
+        styleId: entry.id,
+        title: entry.title ?? entry.id,
+        uri: `honua://styles/${encodeURIComponent(entry.id)}`,
+    }));
+    return {
+        contents: [
+            {
+                uri,
+                mimeType: "application/json",
+                text: JSON.stringify({ styles, default: list.default ?? null }, null, 2),
+            },
+        ],
+    };
+}
+/** Structured "not available on this target" resource body (platform-free mode). */
+function unavailableContents(resourceUri, reason) {
+    return {
+        contents: [
+            {
+                uri: resourceUri,
+                mimeType: "application/json",
+                text: JSON.stringify(capabilityUnavailablePayload(STYLE_SURFACE, reason, STYLE_GUIDANCE), null, 2),
+            },
+        ],
+    };
+}
+/**
+ * Read a single style as a `StyleRef` projection (style_id / title /
+ * description / style_version / encodings / legend_url), resolved against the
+ * server's `/ogc/styles/{styleId}` surface.
+ */
+export async function read(client, styleId) {
+    let styleRef;
+    try {
+        styleRef = await resolveStyleRef(client, styleId);
+    }
+    catch (err) {
+        if (err instanceof CapabilityUnavailableError) {
+            return unavailableContents(`honua://styles/${encodeURIComponent(styleId)}`, err.reason);
+        }
+        throw err;
+    }
+    return {
+        contents: [
+            {
+                uri: `honua://styles/${encodeURIComponent(styleId)}`,
+                mimeType: "application/json",
+                text: JSON.stringify(styleRef, null, 2),
+            },
+        ],
+    };
+}

package/dist/src/styles.d.ts

@@ -0,0 +1,112 @@
+import type { HonuaClient } from "@honua/sdk-js";
+/** Human label for the Honua-only styling surface (capability degradation). */
+export declare const STYLE_SURFACE = "OGC API - Styles";
+/**
+ * Thin read-only client over the server's OGC API – Styles surface
+ * (honua-server, ADR-0048):
+ *
+ *   GET /ogc/styles                     -> styles list   ({ styles: [{ id, title, links }], default? })
+ *   GET /ogc/styles/{styleId}/metadata  -> style metadata ({ id, title, description, keywords, license, version, links })
+ *   GET /ogc/styles/{styleId}           -> stylesheet body (MapLibre/Mapbox JSON by default; SLD via Accept)
+ *
+ * These helpers project the server responses into the geospatial-grpc
+ * `StyleRef` / `StyleEncoding` shape (style_id / title / encodings) so the MCP
+ * resource + `get_style` tool surface a single canonical style object.
+ *
+ * The MCP package only consumes the public {@link HonuaClient.pipelineFetch}
+ * request pipeline (auth / retry / timeout / interceptors) rather than a
+ * private route, matching the other `/ogc/*` consumers in the SDK.
+ *
+ * @module
+ */
+/** Default path prefix for the server's OGC API – Styles surface. */
+export declare const OGC_STYLES_PATH = "/ogc/styles";
+/** MapLibre / Mapbox style media type (server default stylesheet encoding). */
+export declare const MAPLIBRE_STYLE_MEDIA_TYPE = "application/vnd.mapbox.style+json";
+/** SLD 1.0 stylesheet media type. */
+export declare const SLD_10_MEDIA_TYPE = "application/vnd.ogc.sld+xml;version=1.0";
+/** SLD 1.1 stylesheet media type. */
+export declare const SLD_11_MEDIA_TYPE = "application/vnd.ogc.sld+xml;version=1.1";
+/**
+ * Stylesheet encodings the MCP surface understands, keyed by the canonical
+ * geospatial-grpc `StyleEncoding.encoding` identifier. The server
+ * content-negotiates these via the `Accept` header.
+ */
+export declare const STYLE_ENCODINGS: {
+    readonly "mapbox-style": "application/vnd.mapbox.style+json";
+    readonly "sld-1.0.0": "application/vnd.ogc.sld+xml;version=1.0";
+    readonly "sld-1.1.0": "application/vnd.ogc.sld+xml;version=1.1";
+};
+/** A geospatial-grpc `StyleEncoding`-aligned encoding identifier. */
+export type StyleEncodingId = keyof typeof STYLE_ENCODINGS;
+/** Hypermedia link entry on an OGC styles document. */
+export interface OgcStyleLink {
+    href: string;
+    rel?: string;
+    type?: string;
+    title?: string;
+}
+/** One entry in the `GET /ogc/styles` styles list. */
+export interface OgcStyleListEntry {
+    id: string;
+    title?: string;
+    links?: OgcStyleLink[];
+}
+/** Response body of `GET /ogc/styles`. */
+export interface OgcStyleList {
+    styles: OgcStyleListEntry[];
+    default?: string;
+    links?: OgcStyleLink[];
+}
+/** Response body of `GET /ogc/styles/{styleId}/metadata`. */
+export interface OgcStyleMetadata {
+    id: string;
+    title?: string;
+    description?: string;
+    keywords?: string[];
+    license?: string;
+    version?: string;
+    links?: OgcStyleLink[];
+}
+/**
+ * A single encoded representation of a style, aligned with the geospatial-grpc
+ * `StyleEncoding` message. The MCP surface carries the inline body for the
+ * MapLibre encoding (the default the server serves) and exposes the alternate
+ * SLD encodings by reference (`storageRef` = the stylesheet URL).
+ */
+export interface StyleEncoding {
+    encoding: StyleEncodingId | string;
+    contentType?: string;
+    inlineBody?: unknown;
+    storageRef?: string;
+}
+/**
+ * Canonical style projection aligned with the geospatial-grpc `StyleRef`
+ * message (`style_id` / `title` / `description` / `style_version` /
+ * `encodings` / `legend_url`).
+ */
+export interface StyleRef {
+    styleId: string;
+    title: string;
+    description: string | null;
+    styleVersion: number | null;
+    legendUrl: string | null;
+    encodings: StyleEncoding[];
+}
+/** List available styles via `GET /ogc/styles`. */
+export declare function listStyles(client: HonuaClient): Promise<OgcStyleList>;
+/** Fetch style metadata via `GET /ogc/styles/{styleId}/metadata`. */
+export declare function getStyleMetadata(client: HonuaClient, styleId: string): Promise<OgcStyleMetadata>;
+/**
+ * Fetch the MapLibre/Mapbox stylesheet body via `GET /ogc/styles/{styleId}`
+ * (content-negotiated to {@link MAPLIBRE_STYLE_MEDIA_TYPE}).
+ */
+export declare function getMapLibreStylesheet(client: HonuaClient, styleId: string): Promise<unknown>;
+/**
+ * Resolve a single style into a `StyleRef` projection: fetch metadata and the
+ * canonical MapLibre stylesheet, and advertise the alternate SLD encodings by
+ * reference. The stylesheet base URL (`{baseUrl}/ogc/styles/{styleId}`) backs
+ * the `storageRef` for the by-reference encodings.
+ */
+export declare function resolveStyleRef(client: HonuaClient, styleId: string): Promise<StyleRef>;
+//# sourceMappingURL=styles.d.ts.map

package/dist/src/styles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"styles.d.ts","sourceRoot":"","sources":["../../src/styles.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAGjD,+EAA+E;AAC/E,eAAO,MAAM,aAAa,qBAAqB,CAAC;AAEhD;;;;;;;;;;;;;;;;;GAiBG;AAEH,qEAAqE;AACrE,eAAO,MAAM,eAAe,gBAAgB,CAAC;AAE7C,+EAA+E;AAC/E,eAAO,MAAM,yBAAyB,sCAAsC,CAAC;AAE7E,qCAAqC;AACrC,eAAO,MAAM,iBAAiB,4CAA4C,CAAC;AAE3E,qCAAqC;AACrC,eAAO,MAAM,iBAAiB,4CAA4C,CAAC;AAE3E;;;;GAIG;AACH,eAAO,MAAM,eAAe;;;;CAIlB,CAAC;AAEX,qEAAqE;AACrE,MAAM,MAAM,eAAe,GAAG,MAAM,OAAO,eAAe,CAAC;AAE3D,uDAAuD;AACvD,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,sDAAsD;AACtD,MAAM,WAAW,iBAAiB;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,YAAY,EAAE,CAAC;CACxB;AAED,0CAA0C;AAC1C,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,iBAAiB,EAAE,CAAC;IAC5B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,YAAY,EAAE,CAAC;CACxB;AAED,6DAA6D;AAC7D,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,YAAY,EAAE,CAAC;CACxB;AAED;;;;;GAKG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,eAAe,GAAG,MAAM,CAAC;IACnC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;;GAIG;AACH,MAAM,WAAW,QAAQ;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,SAAS,EAAE,aAAa,EAAE,CAAC;CAC5B;AAqCD,mDAAmD;AACnD,wBAAsB,UAAU,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC,CAuB3E;AAED,qEAAqE;AACrE,wBAAsB,gBAAgB,CAAC,MAAM,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAGtG;AAED;;;GAGG;AACH,wBAAsB,qBAAqB,CAAC,MAAM,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAElG;AASD;;;;;GAKG;AACH,wBAAsB,eAAe,CAAC,MAAM,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,CA4B7F"}

package/dist/src/styles.js

@@ -0,0 +1,144 @@
+import { CapabilityUnavailableError } from "./capability.js";
+/** Human label for the Honua-only styling surface (capability degradation). */
+export const STYLE_SURFACE = "OGC API - Styles";
+/**
+ * Thin read-only client over the server's OGC API – Styles surface
+ * (honua-server, ADR-0048):
+ *
+ *   GET /ogc/styles                     -> styles list   ({ styles: [{ id, title, links }], default? })
+ *   GET /ogc/styles/{styleId}/metadata  -> style metadata ({ id, title, description, keywords, license, version, links })
+ *   GET /ogc/styles/{styleId}           -> stylesheet body (MapLibre/Mapbox JSON by default; SLD via Accept)
+ *
+ * These helpers project the server responses into the geospatial-grpc
+ * `StyleRef` / `StyleEncoding` shape (style_id / title / encodings) so the MCP
+ * resource + `get_style` tool surface a single canonical style object.
+ *
+ * The MCP package only consumes the public {@link HonuaClient.pipelineFetch}
+ * request pipeline (auth / retry / timeout / interceptors) rather than a
+ * private route, matching the other `/ogc/*` consumers in the SDK.
+ *
+ * @module
+ */
+/** Default path prefix for the server's OGC API – Styles surface. */
+export const OGC_STYLES_PATH = "/ogc/styles";
+/** MapLibre / Mapbox style media type (server default stylesheet encoding). */
+export const MAPLIBRE_STYLE_MEDIA_TYPE = "application/vnd.mapbox.style+json";
+/** SLD 1.0 stylesheet media type. */
+export const SLD_10_MEDIA_TYPE = "application/vnd.ogc.sld+xml;version=1.0";
+/** SLD 1.1 stylesheet media type. */
+export const SLD_11_MEDIA_TYPE = "application/vnd.ogc.sld+xml;version=1.1";
+/**
+ * Stylesheet encodings the MCP surface understands, keyed by the canonical
+ * geospatial-grpc `StyleEncoding.encoding` identifier. The server
+ * content-negotiates these via the `Accept` header.
+ */
+export const STYLE_ENCODINGS = {
+    "mapbox-style": MAPLIBRE_STYLE_MEDIA_TYPE,
+    "sld-1.0.0": SLD_10_MEDIA_TYPE,
+    "sld-1.1.0": SLD_11_MEDIA_TYPE,
+};
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function getJson(client, path, accept) {
+    let response;
+    try {
+        response = await client.pipelineFetch("GET", path, { headers: { Accept: accept } });
+    }
+    catch (err) {
+        // A plain FeatureServer / OGC-Features endpoint has no styling surface, so
+        // `GET /ogc/styles*` fails (404, network error, or the SDK's non-2xx throw).
+        // Degrade gracefully rather than surfacing a raw crash.
+        throw new CapabilityUnavailableError(STYLE_SURFACE, `request to ${path} failed: ${errorMessage(err)}`);
+    }
+    if (!response.ok) {
+        throw new CapabilityUnavailableError(STYLE_SURFACE, `${path} returned HTTP ${response.status}`);
+    }
+    try {
+        return (await response.json());
+    }
+    catch {
+        throw new CapabilityUnavailableError(STYLE_SURFACE, `${path} did not return JSON (target has no OGC API - Styles surface)`);
+    }
+}
+function errorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+function stylePath(styleId) {
+    return `${OGC_STYLES_PATH}/${encodeURIComponent(styleId)}`;
+}
+/** List available styles via `GET /ogc/styles`. */
+export async function listStyles(client) {
+    const body = await getJson(client, OGC_STYLES_PATH, "application/json");
+    if (!isRecord(body) || !Array.isArray(body.styles)) {
+        // A well-formed styles document always carries a `styles` array (possibly
+        // empty). Anything else means the target is not an OGC API - Styles surface;
+        // report that honestly instead of returning a misleading empty catalog.
+        throw new CapabilityUnavailableError(STYLE_SURFACE, `${OGC_STYLES_PATH} response is not a styles document`);
+    }
+    const styles = [];
+    for (const entry of body.styles) {
+        if (isRecord(entry) && typeof entry.id === "string") {
+            styles.push({
+                id: entry.id,
+                ...(typeof entry.title === "string" ? { title: entry.title } : {}),
+                ...(Array.isArray(entry.links) ? { links: entry.links } : {}),
+            });
+        }
+    }
+    return {
+        styles,
+        ...(typeof body.default === "string" ? { default: body.default } : {}),
+        ...(Array.isArray(body.links) ? { links: body.links } : {}),
+    };
+}
+/** Fetch style metadata via `GET /ogc/styles/{styleId}/metadata`. */
+export async function getStyleMetadata(client, styleId) {
+    const body = await getJson(client, `${stylePath(styleId)}/metadata`, "application/json");
+    return body;
+}
+/**
+ * Fetch the MapLibre/Mapbox stylesheet body via `GET /ogc/styles/{styleId}`
+ * (content-negotiated to {@link MAPLIBRE_STYLE_MEDIA_TYPE}).
+ */
+export async function getMapLibreStylesheet(client, styleId) {
+    return getJson(client, stylePath(styleId), `${MAPLIBRE_STYLE_MEDIA_TYPE}, application/json;q=0.9`);
+}
+/** Coerce a free-form metadata `version` (string) into the numeric style_version, when possible. */
+function parseStyleVersion(version) {
+    if (version === undefined)
+        return null;
+    const parsed = Number.parseInt(version, 10);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+/**
+ * Resolve a single style into a `StyleRef` projection: fetch metadata and the
+ * canonical MapLibre stylesheet, and advertise the alternate SLD encodings by
+ * reference. The stylesheet base URL (`{baseUrl}/ogc/styles/{styleId}`) backs
+ * the `storageRef` for the by-reference encodings.
+ */
+export async function resolveStyleRef(client, styleId) {
+    const [metadata, maplibre] = await Promise.all([
+        getStyleMetadata(client, styleId).catch(() => null),
+        getMapLibreStylesheet(client, styleId),
+    ]);
+    const stylesheetUrl = `${client.serverBaseUrl}${stylePath(styleId)}`;
+    const encodings = [
+        {
+            encoding: "mapbox-style",
+            contentType: MAPLIBRE_STYLE_MEDIA_TYPE,
+            inlineBody: maplibre,
+        },
+        { encoding: "sld-1.0.0", contentType: SLD_10_MEDIA_TYPE, storageRef: stylesheetUrl },
+        { encoding: "sld-1.1.0", contentType: SLD_11_MEDIA_TYPE, storageRef: stylesheetUrl },
+    ];
+    const legendUrl = metadata?.links?.find((l) => l.rel === "preview")?.href ?? null;
+    return {
+        styleId,
+        title: metadata?.title ?? styleId,
+        description: metadata?.description ?? null,
+        styleVersion: parseStyleVersion(metadata?.version),
+        legendUrl,
+        encodings,
+    };
+}

package/dist/src/tools/apply-style-preset.d.ts

@@ -0,0 +1,27 @@
+import type { HonuaClient } from "@honua/sdk-js";
+import { z } from "zod";
+export declare const schema: z.ZodObject<{
+    styleId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    styleId: string;
+}, {
+    styleId: string;
+}>;
+export type Input = z.infer<typeof schema>;
+/**
+ * Resolve a style preset for client-side application. Returns the canonical
+ * `StyleRef` plus the MapLibre/Mapbox stylesheet body so an agent or downstream
+ * runtime can apply the preset to a map.
+ *
+ * This is a read-only inspection projection: it resolves and returns the
+ * preset's stylesheet but never mutates server state. Persisting a preset onto
+ * a map or published service stays with the typed gRPC execution layer per the
+ * MCP boundary (geospatial-mcp taxonomy / ADR-0028).
+ */
+export declare function execute(client: HonuaClient, input: Input): Promise<{
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+}>;
+//# sourceMappingURL=apply-style-preset.d.ts.map

package/dist/src/tools/apply-style-preset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply-style-preset.d.ts","sourceRoot":"","sources":["../../../src/tools/apply-style-preset.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AASxB,eAAO,MAAM,MAAM;;;;;;EAEjB,CAAC;AAEH,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,MAAM,CAAC,CAAC;AAE3C;;;;;;;;;GASG;AACH,wBAAsB,OAAO,CAAC,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,KAAK;;;;;GAqB9D"}

package/dist/src/tools/apply-style-preset.js

@@ -0,0 +1,41 @@
+import { z } from "zod";
+import { CapabilityUnavailableError, capabilityUnavailable } from "../capability.js";
+import { jsonText } from "../helpers.js";
+import { STYLE_SURFACE, resolveStyleRef } from "../styles.js";
+const STYLE_GUIDANCE = "This target is a plain FeatureServer/OGC endpoint with no style presets. " +
+    "Build a MapLibre style client-side from the layer's fields, or use a Honua deployment for managed presets.";
+export const schema = z.object({
+    styleId: z.string().describe("Stable style identifier of the preset to resolve."),
+});
+/**
+ * Resolve a style preset for client-side application. Returns the canonical
+ * `StyleRef` plus the MapLibre/Mapbox stylesheet body so an agent or downstream
+ * runtime can apply the preset to a map.
+ *
+ * This is a read-only inspection projection: it resolves and returns the
+ * preset's stylesheet but never mutates server state. Persisting a preset onto
+ * a map or published service stays with the typed gRPC execution layer per the
+ * MCP boundary (geospatial-mcp taxonomy / ADR-0028).
+ */
+export async function execute(client, input) {
+    // `resolveStyleRef` already fetches the MapLibre stylesheet and inlines it on
+    // the `mapbox-style` encoding, so reuse that body instead of issuing a second
+    // identical GET /ogc/styles/{id}.
+    let styleRef;
+    try {
+        styleRef = await resolveStyleRef(client, input.styleId);
+    }
+    catch (err) {
+        if (err instanceof CapabilityUnavailableError) {
+            return capabilityUnavailable(STYLE_SURFACE, err.reason, STYLE_GUIDANCE);
+        }
+        throw err;
+    }
+    const stylesheet = styleRef.encodings.find((e) => e.encoding === "mapbox-style")?.inlineBody ?? null;
+    return jsonText({
+        style: styleRef,
+        stylesheet,
+        application: "client-side",
+        note: "Apply this MapLibre stylesheet client-side. MCP does not mutate server state; persisting a preset to a map or service uses the gRPC execution layer.",
+    });
+}

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

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

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { GEOMETRY_TYPES, jsonText, mapSpatialRel, resolveGeometryType } from "../helpers.js";
+import { GEOMETRY_TYPES, coerceCount, jsonText, mapSpatialRel, resolveGeometryType } from "../helpers.js";
 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"),
@@ -26,9 +26,10 @@ export async function execute(client, input) {
         outFields: "OBJECTID",
         extraParams: { returnCountOnly: true },
     }));
-    const hasCount = Object.prototype.hasOwnProperty.call(response, "count");
-    const count = response.count;
-    if (!hasCount || typeof count !== "number" || !Number.isFinite(count)) {
+    // The default grpc-web transport returns very large counts as a string to
+    // preserve precision beyond Number.MAX_SAFE_INTEGER; accept both forms.
+    const count = coerceCount(response.count);
+    if (count === undefined) {
         throw new Error("Count query did not return a numeric count.");
     }
     return jsonText({ count });

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;AAGxB,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;EAajB,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;;;;;GAmC9D"}
+{"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;AAGxB,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;EAajB,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;;;;;GAoC9D"}

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

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { GEOMETRY_TYPES, jsonText, mapSpatialRel, resolveGeometryType } from "../helpers.js";
+import { GEOMETRY_TYPES, coerceCount, jsonText, mapSpatialRel, resolveGeometryType } from "../helpers.js";
 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"),
@@ -25,8 +25,9 @@ export async function execute(client, input) {
         returnGeometry: false,
         extraParams: { returnExtentOnly: true },
     }));
-    const hasCount = Object.prototype.hasOwnProperty.call(response, "count");
-    const count = hasCount && typeof response.count === "number" && Number.isFinite(response.count) ? response.count : undefined;
+    // Accept large counts returned as strings by the grpc-web transport (chosen
+    // to preserve precision beyond Number.MAX_SAFE_INTEGER) as well as numbers.
+    const count = coerceCount(response.count);
     const hasExtent = Object.prototype.hasOwnProperty.call(response, "extent");
     if (!hasExtent) {
         // Some backends can return count-only payloads for empty extent queries.
@@ -39,7 +40,8 @@ export async function execute(client, input) {
     if (response.extent === null) {
         extent = null;
     }
-    else if (typeof response.extent === "object") {
+    else if (typeof response.extent === "object" && !Array.isArray(response.extent)) {
+        // A JSON array is `typeof "object"` but is not a valid extent envelope.
         extent = response.extent;
     }
     else {

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

@@ -0,0 +1,24 @@
+import type { HonuaClient } from "@honua/sdk-js";
+import { z } from "zod";
+export declare const schema: z.ZodObject<{
+    styleId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    styleId?: string | undefined;
+}, {
+    styleId?: string | undefined;
+}>;
+export type Input = z.infer<typeof schema>;
+/**
+ * Resolve a style from the server's OGC API – Styles surface. With a `styleId`,
+ * returns the canonical `StyleRef` projection (style_id / title / description /
+ * style_version / encodings / legend_url), with the MapLibre stylesheet inlined.
+ * Without a `styleId`, returns the styles catalog so an agent can discover what
+ * is available.
+ */
+export declare function execute(client: HonuaClient, input: Input): Promise<{
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+}>;
+//# sourceMappingURL=get-style.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"get-style.d.ts","sourceRoot":"","sources":["../../../src/tools/get-style.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AASxB,eAAO,MAAM,MAAM;;;;;;EAEjB,CAAC;AAEH,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,MAAM,CAAC,CAAC;AAE3C;;;;;;GAMG;AACH,wBAAsB,OAAO,CAAC,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,KAAK;;;;;GAsB9D"}

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

@@ -0,0 +1,39 @@
+import { z } from "zod";
+import { CapabilityUnavailableError, capabilityUnavailable } from "../capability.js";
+import { jsonText } from "../helpers.js";
+import { STYLE_SURFACE, listStyles, resolveStyleRef } from "../styles.js";
+const STYLE_GUIDANCE = "This target is a plain FeatureServer/OGC endpoint with no server-side style catalog. " +
+    "Query features and build a MapLibre style client-side, or point honua-mcp at a Honua deployment for managed styles.";
+export const schema = z.object({
+    styleId: z.string().optional().describe("Stable style identifier. Omit to list the styles available on the server."),
+});
+/**
+ * Resolve a style from the server's OGC API – Styles surface. With a `styleId`,
+ * returns the canonical `StyleRef` projection (style_id / title / description /
+ * style_version / encodings / legend_url), with the MapLibre stylesheet inlined.
+ * Without a `styleId`, returns the styles catalog so an agent can discover what
+ * is available.
+ */
+export async function execute(client, input) {
+    try {
+        if (!input.styleId) {
+            const list = await listStyles(client);
+            return jsonText({
+                styles: list.styles.map((entry) => ({
+                    styleId: entry.id,
+                    title: entry.title ?? entry.id,
+                    uri: `honua://styles/${encodeURIComponent(entry.id)}`,
+                })),
+                default: list.default ?? null,
+            });
+        }
+        const styleRef = await resolveStyleRef(client, input.styleId);
+        return jsonText(styleRef);
+    }
+    catch (err) {
+        if (err instanceof CapabilityUnavailableError) {
+            return capabilityUnavailable(STYLE_SURFACE, err.reason, STYLE_GUIDANCE);
+        }
+        throw err;
+    }
+}

package/dist/src/tools/list-services.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"list-services.d.ts","sourceRoot":"","sources":["../../../src/tools/list-services.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,MAAM;;;;;;EAQjB,CAAC;AAEH,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,MAAM,CAAC,CAAC;AAI3C,wBAAsB,OAAO,CAAC,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,KAAK;;;;;GAgC9D"}
+{"version":3,"file":"list-services.d.ts","sourceRoot":"","sources":["../../../src/tools/list-services.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,MAAM;;;;;;EAQjB,CAAC;AAEH,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,MAAM,CAAC,CAAC;AAI3C,wBAAsB,OAAO,CAAC,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,KAAK;;;;;GA+C9D"}

package/dist/src/tools/list-services.js

@@ -9,7 +9,22 @@ export const schema = z.object({
 });
 const METADATA_CONCURRENCY = 8;
 export async function execute(client, input) {
-    const response = await client.listServices();
+    let response;
+    try {
+        response = await client.listServices();
+    }
+    catch (err) {
+        // Some targets expose no service catalog at `/rest/services` — e.g. a base
+        // URL pointed straight at a single FeatureServer, or an OGC-only endpoint.
+        // Degrade to a structured note instead of crashing: the agent can still
+        // describe/query a known service+layer directly.
+        return jsonText({
+            catalogAvailable: false,
+            services: [],
+            reason: `service catalog is not available on this target: ${err instanceof Error ? err.message : String(err)}`,
+            guidance: "No /rest/services directory here. Call honua_describe_layer / honua_query_features with a known serviceId and layerId, or point the base URL at an ArcGIS folder that lists services.",
+        });
+    }
     const services = (response.services ?? []).filter((s) => s.type === "FeatureServer");
     if (!input.includeDetails) {
         return jsonText(services.map((s) => ({ serviceId: s.name, type: s.type })));

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;;;;;GA4B9D"}
+{"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"}

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

@@ -24,7 +24,10 @@ export async function execute(client, input) {
         serviceId: input.serviceId,
         layerId: input.layerId,
         where: input.where,
-        outFields: input.outFields ?? "*",
+        // 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),