@arcgis/ai-components 5.2.0-next.1 → 5.2.0-next.100

package/dist/agents/tools/navigation/goToViewpoint/adapter.js

@@ -0,0 +1,42 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+import t from "zod";
+import { tool as c } from "@langchain/core/tools";
+import l from "@arcgis/core/geometry/Point.js";
+import { f as r } from "../../../../chunks/fetchAgentContext.js";
+async function m(e, a, o) {
+  const i = {
+    target: new l({
+      longitude: e.longitude,
+      latitude: e.latitude,
+      spatialReference: { wkid: 4326 }
+    })
+  };
+  return o?.zoom !== void 0 && (i.zoom = o.zoom), o?.scale !== void 0 && (i.scale = o.scale), await a.goTo(i), { text: `Successfully navigated to: ${[
+    `(${e.latitude}°, ${e.longitude}°)`,
+    o?.zoom !== void 0 ? `zoom ${o.zoom}` : "",
+    o?.scale !== void 0 ? `scale 1:${o.scale}` : ""
+  ].filter(Boolean).join(", ")}` };
+}
+async function d({
+  center: e,
+  zoom: a,
+  scale: o
+}, n) {
+  const { mapView: i } = r(n, ["mapView"]);
+  return await m(e, i, { zoom: a, scale: o });
+}
+const s = t.object({
+  center: t.object({
+    longitude: t.number().describe("The longitude (x-coordinate) of the point to navigate to."),
+    latitude: t.number().describe("The latitude (y-coordinate) of the point to navigate to.")
+  }),
+  zoom: t.number().optional().describe("The zoom level. Higher values = more zoomed in."),
+  scale: t.number().optional().describe("The map scale. Alternative to zoom. Smaller numbers = more zoomed in.")
+}), T = c(d, {
+  name: "goToViewpoint",
+  description: "Go to the specified viewpoint. This can contain a combination of scale, center, zoom, etc.",
+  schema: s
+});
+export {
+  T as goToViewpointTool
+};

package/dist/agents/tools/navigation/goToZoom/adapter.d.ts

@@ -0,0 +1,8 @@
+import type { StructuredToolInterface } from "@langchain/core/tools";
+
+/**
+ * Navigates the map to a specified zoom level.
+ *
+ * @internal
+ */
+export const goToZoomTool: StructuredToolInterface;

package/dist/agents/tools/navigation/goToZoom/adapter.js

@@ -0,0 +1,21 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+import t from "zod";
+import { tool as m } from "@langchain/core/tools";
+import { f as i } from "../../../../chunks/fetchAgentContext.js";
+async function r(o, e) {
+  return await e.goTo({ zoom: o }), { text: `Successfully zoomed to: ${o}` };
+}
+async function a({ zoom: o }, e) {
+  const { mapView: n } = i(e, ["mapView"]);
+  return await r(o, n);
+}
+const c = t.object({
+  zoom: t.number().min(1).max(20).describe("The zoom level of the view to go to.")
+}), l = m(a, {
+  name: "goToZoom",
+  description: 'Go to the specified zoom level. If input is generic (e.g. "zoom in", then only zoom to the next appropriate level - increase level for zooming in and decrease for zooming out.).',
+  schema: c
+});
+export {
+  l as goToZoomTool
+};

package/dist/agents/tools/query/getAttribute/adapter.d.ts

@@ -0,0 +1,8 @@
+import type { StructuredToolInterface } from "@langchain/core/tools";
+
+/**
+ * Returns a formatted field value from the first feature matching a query.
+ *
+ * @internal
+ */
+export const getAttributeTool: StructuredToolInterface;

package/dist/agents/tools/query/getAttribute/adapter.js

@@ -0,0 +1,40 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+import { tool as f } from "@langchain/core/tools";
+import i from "zod";
+import { f as h, g } from "../../../../chunks/formatFeatureAttributes.js";
+import { f as y } from "../../../../chunks/fetchAgentContext.js";
+const b = (a, e, o) => {
+  const t = a.createQuery();
+  return t.outFields = [e], t.where = o || "1=1", t.num = 1, t;
+}, d = async (a, e, o, t) => {
+  const r = t.map?.allLayers.find((m) => m.id === a), n = b(r, e, o.where), u = (await r.queryFeatures(n)).features[0], c = u ? u.attributes[e] : null, l = h(r, e, c, t.timeZone), s = g(r, e);
+  return {
+    tool: "getAttribute",
+    layerName: r.title ?? a,
+    summary: `${s} = ${l}`,
+    details: {
+      fieldName: e,
+      fieldAlias: s !== e ? s : void 0,
+      value: l,
+      where: o.where
+    }
+  };
+};
+async function p({ layerId: a, fieldName: e, query: o }, t) {
+  const { mapView: r } = y(t, ["mapView"]), n = await d(a, e, o, r);
+  return JSON.stringify(n, null, 2);
+}
+const w = i.object({
+  layerId: i.string().describe("The layerId of the layer containing the field from which to get a value."),
+  fieldName: i.string().describe("The name of the field/attribute from which to get a field value."),
+  query: i.object({
+    where: i.string().describe("The SQL-92 where clause representing the feature from which to get an attribute value.")
+  })
+}), Q = f(p, {
+  name: "getAttribute",
+  description: "Returns an attribute value for a given feature.",
+  schema: w
+});
+export {
+  Q as getAttributeTool
+};

package/dist/agents/tools/query/getStatistics/adapter.d.ts

@@ -0,0 +1,8 @@
+import type { StructuredToolInterface } from "@langchain/core/tools";
+
+/**
+ * Calculates an aggregate statistic for a field with optional spatial filtering.
+ *
+ * @internal
+ */
+export const getStatisticsTool: StructuredToolInterface;

package/dist/agents/tools/query/getStatistics/adapter.js

@@ -0,0 +1,157 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+import { tool as L } from "@langchain/core/tools";
+import t from "zod";
+import E from "@arcgis/core/smartMapping/statistics/summaryStatistics.js";
+import R from "@arcgis/core/smartMapping/statistics/uniqueValues.js";
+import V from "@arcgis/core/layers/support/FeatureFilter.js";
+import { c as x, m as v } from "../../../../chunks/mergeWhereClauses.js";
+import { g as O, i as S, a as C, d as I, s as N, r as G } from "../../../../chunks/resolvePointGeometryFilter.js";
+import { f as U } from "../../../../chunks/fetchAgentContext.js";
+import { f as W } from "../../../../chunks/fetchService.js";
+const j = async (h) => {
+  const { targetLayer: a, fieldName: n, statisticType: l, mapView: i, layersAndFieldsRegistry: p, geometryFilter: e } = h, s = i.map?.allLayers.find((r) => r.id === a.layerId);
+  if (!s)
+    throw new Error(`Layer '${a.layerId}' not found.`);
+  const w = await i.whenLayerView(s), o = p.get(a.layerId)?.fieldRegistry.get(n), F = o?.alias;
+  if (!o)
+    throw new Error(`Field '${n}' not found.`);
+  let b, u;
+  if (e) {
+    const r = await O(e, i);
+    if ("error" in r)
+      throw new Error(r.error);
+    if (!r.geometry)
+      throw S(e) ? new Error(`No features found matching: ${e.where}`) : new Error("Failed to create geometry");
+    if (S(e)) {
+      const g = i.map?.allLayers.find((f) => f.id === e.layerId);
+      b = {
+        geometryLayerName: g?.title ?? g?.id,
+        geometryLayerId: e.layerId,
+        geometryWhere: e.where,
+        distance: e.distance,
+        units: e.units,
+        applied: !0
+      };
+    } else C(e) && (b = {
+      point: e.point,
+      distance: e.distance,
+      units: e.units,
+      applied: !0
+    });
+    u = new V({
+      geometry: r.geometry,
+      distance: e.distance,
+      units: e.units,
+      spatialRelationship: "intersects"
+    });
+  }
+  const y = x(w, [n], !1);
+  let d = null, m = null;
+  const T = 10;
+  if (o.type !== "geometry" && o.type !== "oid" && o.type !== "global-id")
+    try {
+      const r = {
+        layer: s,
+        useFeaturesInView: y,
+        view: y ? i : void 0,
+        field: n,
+        sqlWhere: v(s.definitionExpression, a.where),
+        ...u && { filter: u },
+        outStatisticTypes: { include: [l] }
+      };
+      d = await E(r);
+      const g = ["string", "small-integer", "integer"], f = o.domain?.type === "coded-value" ? o.domain : null;
+      (g.includes(o.type) || f) && (m = (await R({
+        layer: s,
+        useFeaturesInView: y,
+        view: y ? i : void 0,
+        field: n,
+        sqlWhere: v(s.definitionExpression, a.where),
+        ...u && { filter: u }
+      })).uniqueValueInfos.sort((c, q) => q.count - c.count).slice(0, T)), m && o.domain?.type === "coded-value" && (m = m.map((c) => ({
+        ...c,
+        value: f ? f.getName(c.value) ?? c.value : c.value
+      })));
+    } catch (r) {
+      console.error("Statistics error:", r);
+    }
+  return {
+    tool: "getStatistics",
+    layerName: s.title ?? a.layerId,
+    summary: `${l} = ${typeof d?.[l] == "number" ? d[l] : "N/A"}`,
+    details: {
+      fieldName: n,
+      fieldAlias: F,
+      statisticType: l,
+      statistic: d?.[l] ?? null,
+      summaryStatistics: d,
+      uniqueValues: m,
+      where: a.where,
+      spatialFilterInfo: b
+    }
+  };
+};
+async function A({
+  targetLayer: h,
+  fieldName: a,
+  statisticType: n,
+  geometryFilter: l
+}, i) {
+  const p = W(i, "layersAndFieldsRegistry"), { mapView: e } = U(i, ["mapView"]), s = G(
+    l,
+    i.state?.agentExecutionContext?.sharedResources
+  ), w = await j({
+    targetLayer: h,
+    fieldName: a,
+    statisticType: n,
+    mapView: e,
+    layersAndFieldsRegistry: p,
+    geometryFilter: s
+  });
+  return JSON.stringify(w, null, 2);
+}
+const D = t.object({
+  layerId: t.string().describe("The layerId of the layer containing the geometry by which to filter."),
+  where: t.string().describe("The SQL-92 where clause representing the features from which to filter."),
+  distance: t.number().optional().describe("The buffer distance around the geometry."),
+  units: I.optional().describe("The units for the distance buffer.")
+}), P = t.object({
+  point: t.object({
+    x: t.number().describe("X coordinate (longitude) from navigation result"),
+    y: t.number().describe("Y coordinate (latitude) from navigation result"),
+    spatialReference: t.object({
+      wkid: t.number().describe("Spatial reference WKID (e.g., 4326 for WGS84)")
+    }).optional().describe("Spatial reference. Defaults to map's spatial reference if not provided.")
+  }).describe("Point coordinates from a previous navigation/geocoding result"),
+  distance: t.number().optional().describe("Optional buffer distance around the point."),
+  units: I.optional().describe("The units for the distance buffer.")
+}), $ = t.object({
+  targetLayer: t.object({
+    layerId: t.string().describe("The layerId of the layer containing the field from which to get a value."),
+    where: t.string().describe("The SQL-92 where clause representing the feature from which to get an attribute value.")
+  }),
+  geometryFilter: t.union([D, P, N]).optional().describe(
+    "Geometry filter for spatial queries. Use 'sharedResourceId' with an ID from listSharedResources for a previously geocoded location. Use 'point' for inline coordinates or 'layerId/where' for features from another layer."
+  ),
+  fieldName: t.string().describe("The name of the field for which to get statistics. STRICTLY DO NOT use OBJECTID. Use any other field"),
+  statisticType: t.enum(["avg", "max", "median", "min", "stddev", "sum", "variance", "nullcount", "count"]).describe("The statistic type to calculate.")
+}), _ = L(A, {
+  name: "getStatistics",
+  description: `Computes a single aggregate statistic (max, min, avg, sum, median, stddev, variance) for a numeric field across matching features. Also returns frequency analysis for categorical fields.
+
+USE THIS TOOL FOR:
+- "What is the average/maximum/minimum/total [field]?" — aggregate computations
+- "Most common/frequent value of [field]?" — frequency analysis
+- Questions requiring a mathematical aggregation across many features
+
+DO NOT USE FOR:
+- "How many features match X?" — use queryFeatures instead (it returns totalCount)
+- "Show / list / find features" — use queryFeatures instead
+- Simple counts of features matching a condition — use queryFeatures instead
+
+Only call this tool when the answer requires computing an aggregate (avg, max, min, sum, median, stddev) over a field's values, not just counting or listing features.`,
+  schema: $
+});
+export {
+  _ as getStatisticsTool
+};

package/dist/agents/tools/query/getTopFeatures/adapter.d.ts

@@ -0,0 +1,8 @@
+import type { StructuredToolInterface } from "@langchain/core/tools";
+
+/**
+ * Returns top-ranked features based on grouping and ordering criteria.
+ *
+ * @internal
+ */
+export const getTopFeaturesTool: StructuredToolInterface;

package/dist/agents/tools/query/getTopFeatures/adapter.js

@@ -0,0 +1,144 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+import { tool as S } from "@langchain/core/tools";
+import e from "zod";
+import T from "@arcgis/core/rest/support/TopFeaturesQuery.js";
+import B from "@arcgis/core/rest/support/TopFilter.js";
+import { m as C, c as v } from "../../../../chunks/mergeWhereClauses.js";
+import { a as I } from "../../../../chunks/formatFeatureAttributes.js";
+import { g as q, d as y, s as x, r as G } from "../../../../chunks/resolvePointGeometryFilter.js";
+import { f as N } from "../../../../chunks/fetchAgentContext.js";
+const k = (s) => s.flatMap((t) => t.split(",")).map((t) => t.trim()).map((t) => t.split(/\s+/u)[0]?.replace(/^"|"$/gu, "")).filter((t) => !!t), R = async (s, t, n, i, l) => {
+  const a = n.map?.allLayers.find((o) => o.id === s.layerId), c = await n.whenLayerView(a), u = a.title ?? s.layerId;
+  let d;
+  if (i) {
+    const o = await q(i, n);
+    if ("error" in o)
+      return {
+        tool: "getTopFeatures",
+        layerName: u,
+        summary: "Geometry lookup failed",
+        details: { error: o.error }
+      };
+    if (!o.geometry)
+      return {
+        tool: "getTopFeatures",
+        layerName: u,
+        summary: "No features found for geometry filter",
+        details: {
+          error: `No features found matching: ${"where" in i ? i.where : "unknown criteria"}`
+        }
+      };
+    d = o.geometry;
+  } else l && (d = n.extent.clone());
+  const p = t.groupByFields && t.groupByFields.length > 0, f = a.objectIdField, h = s.outFields.includes("*") ? ["*"] : [.../* @__PURE__ */ new Set([...s.outFields, f])];
+  try {
+    let o;
+    if (p) {
+      const r = new T({
+        where: s.where || "1=1",
+        outFields: h,
+        orderByFields: s.orderByFields,
+        geometry: d,
+        spatialRelationship: d ? "intersects" : void 0,
+        distance: i?.distance,
+        units: i?.units,
+        topFilter: new B({
+          topCount: t.topCount,
+          groupByFields: t.groupByFields,
+          orderByFields: t.orderByFields
+        })
+      });
+      o = await a.queryTopFeatures(r);
+    } else {
+      const r = a.createQuery();
+      r.where = C(a.definitionExpression, s.where || "1=1"), r.outFields = h.length ? h : ["*"], r.orderByFields = t.orderByFields, r.returnGeometry = !1, r.num = t.topCount, d && (r.geometry = d, r.spatialRelationship = "intersects"), i?.distance && (r.distance = i.distance), i?.units && (r.units = i.units), r.outSpatialReference = n.spatialReference;
+      const m = [
+        .../* @__PURE__ */ new Set([...s.outFields, ...k(t.orderByFields)])
+      ], w = v(c, m, l ?? !1);
+      try {
+        o = w ? await c.queryFeatures(r) : await a.queryFeatures(r);
+      } catch (F) {
+        console.warn("Client-side query failed, falling back to server:", F), o = await a.queryFeatures(r);
+      }
+    }
+    const g = o.features.map((r) => r.attributes[f]), { attributes: b } = I(a, o, n.timeZone);
+    return {
+      tool: "getTopFeatures",
+      layerName: u,
+      summary: `Top ${t.topCount} features extracted`,
+      details: {
+        topCount: t.topCount,
+        attributes: b,
+        objectIds: g,
+        objectIdField: f,
+        where: s.where,
+        orderByFields: t.orderByFields,
+        ...p && { groupByFields: t.groupByFields }
+      }
+    };
+  } catch (o) {
+    return {
+      tool: "getTopFeatures",
+      layerName: u,
+      summary: "Query failed",
+      details: { error: o instanceof Error ? o.message : String(o) }
+    };
+  }
+}, j = async ({
+  targetLayer: s,
+  topFilter: t,
+  geometryFilter: n,
+  useCurrentExtent: i
+}, l) => {
+  const { mapView: a } = N(l, ["mapView"]), c = G(
+    n,
+    l.state?.agentExecutionContext?.sharedResources
+  ), u = await R(s, t, a, c, i);
+  return JSON.stringify(u, null, 2);
+}, D = e.object({
+  layerId: e.string().describe("The layerId of the layer containing the geometry by which to filter."),
+  where: e.string().describe("The SQL-92 where clause representing the features from which to filter."),
+  distance: e.number().optional().describe("The buffer distance around the geometry."),
+  units: y.optional().describe("The units for the distance buffer.")
+}), Q = e.object({
+  point: e.object({
+    x: e.number().describe("X coordinate (longitude) from navigation result"),
+    y: e.number().describe("Y coordinate (latitude) from navigation result"),
+    spatialReference: e.object({
+      wkid: e.number().describe("Spatial reference WKID (e.g., 4326 for WGS84)")
+    }).optional().describe("Spatial reference. Defaults to map's spatial reference if not provided.")
+  }).describe("Point coordinates from a previous navigation/geocoding result"),
+  distance: e.number().optional().describe("Optional buffer distance around the point."),
+  units: y.optional().describe("The units for the distance buffer.")
+}), U = e.object({
+  targetLayer: e.object({
+    layerId: e.string().describe("The layerId of the layer containing the field from which to get a value."),
+    where: e.string().describe("The SQL-92 where clause representing the feature from which to get an attribute value."),
+    orderByFields: e.array(e.string().describe("The field(s) and order for which to sort the resulting features.")),
+    outFields: e.array(
+      e.string().describe(
+        'The fields to include in the output that will be presented to the user. This should include identifying information about the resulting features, like a name or id, along with the values desired in the output. If unsure, choose all fields ("*").'
+      ).default("*")
+    )
+  }),
+  geometryFilter: e.union([D, Q, x]).optional().describe(
+    "Geometry filter for spatial queries. Use 'sharedResourceId' with an ID from listSharedResources for a previously geocoded location. Use 'point' for inline coordinates or 'layerId/where' for features from another layer."
+  ),
+  topFilter: e.object({
+    topCount: e.number().describe("Number of top features to return per group."),
+    orderByFields: e.array(
+      e.string().describe("Field(s) to rank by with ASC/DESC. Must be existing field names, not aggregate functions.")
+    ),
+    groupByFields: e.array(e.string().describe("Field(s) to group results by. Returns top N per group."))
+  }).required(),
+  useCurrentExtent: e.boolean().optional().describe(
+    "Set to true ONLY when user explicitly asks about features 'in my view', 'on my map', 'I am looking at'. Default is false (queries entire layer)."
+  )
+}), J = S(j, {
+  name: "getTopFeatures",
+  description: 'Returns top N features ranked by an existing field value. Use for "highest", "lowest", "top N" questions where ranking is based on a field that already exists in the data (e.g., population, value, date, depth). orderByFields must be actual field names with ASC/DESC. Do NOT use aggregate functions like COUNT(), SUM(), AVG() - those require getStatistics.',
+  schema: U
+});
+export {
+  J as getTopFeaturesTool
+};

package/dist/agents/tools/query/queryFeatures/adapter.d.ts

@@ -0,0 +1,8 @@
+import type { StructuredToolInterface } from "@langchain/core/tools";
+
+/**
+ * Returns the count and attributes of features matching query constraints.
+ *
+ * @internal
+ */
+export const queryFeaturesTool: StructuredToolInterface;

package/dist/agents/tools/query/queryFeatures/adapter.js

@@ -0,0 +1,130 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+import { tool as v } from "@langchain/core/tools";
+import { a as C } from "../../../../chunks/formatFeatureAttributes.js";
+import { g as R, i as F, a as I, d as q, s as G, r as O } from "../../../../chunks/resolvePointGeometryFilter.js";
+import { c as j, m as x } from "../../../../chunks/mergeWhereClauses.js";
+import t from "zod";
+import { f as N } from "../../../../chunks/fetchAgentContext.js";
+const p = 25, W = (i) => i.flatMap((r) => r.split(",")).map((r) => r.trim()).map((r) => r.split(/\s+/u)[0]?.replace(/^"|"$/gu, "")).filter((r) => !!r), B = async (i, r, e, l) => {
+  const a = r.map?.allLayers.find((u) => u.id === i.layerId), d = await r.whenLayerView(a), f = a.title ?? i.layerId;
+  let h;
+  if (e) {
+    const u = await R(e, r);
+    if ("error" in u) {
+      const s = { error: u.error };
+      if (F(e)) {
+        const c = r.map?.allLayers.find((y) => y.id === e.layerId);
+        s.geometryLayerName = c?.title ?? c?.id, s.geometryLayerId = e.layerId, s.geometryWhere = e.where;
+      } else I(e) && (s.point = e.point);
+      return {
+        tool: "queryFeatures",
+        layerName: f,
+        summary: "Geometry lookup failed",
+        details: s
+      };
+    }
+    if (!u.geometry) {
+      const s = {};
+      if (F(e)) {
+        const c = r.map?.allLayers.find((y) => y.id === e.layerId);
+        s.error = `No features found matching: ${e.where}`, s.geometryLayerName = c?.title ?? c?.id, s.geometryLayerId = e.layerId, s.geometryWhere = e.where;
+      } else I(e) && (s.error = "Failed to create point geometry", s.point = e.point);
+      return {
+        tool: "queryFeatures",
+        layerName: f,
+        summary: "No features found for geometry filter",
+        details: s
+      };
+    }
+    h = u.geometry;
+  } else l && (h = r.extent.clone());
+  const T = [
+    .../* @__PURE__ */ new Set([...i.outFields, ...W(i.orderByFields)])
+  ], b = j(d, T, l ?? !1), w = a.objectIdField, o = a.createQuery();
+  o.where = x(a.definitionExpression, i.where || "1=1"), o.outFields = i.outFields.includes("*") ? ["*"] : [.../* @__PURE__ */ new Set([...i.outFields, w])], o.orderByFields = i.orderByFields, h && (o.geometry = h, o.spatialRelationship = "intersects"), e?.distance && (o.distance = e.distance), e?.units && (o.units = e.units), o.outSpatialReference = r.spatialReference;
+  let n, m;
+  try {
+    n = b ? await d.queryFeatureCount(o) : await a.queryFeatureCount(o), n > 0 && n <= p && (m = b ? await d.queryFeatures(o) : await a.queryFeatures(o));
+  } catch (u) {
+    console.warn("Client-side query failed, falling back to server:", u), n = await a.queryFeatureCount(o), n > 0 && n <= p && (m = await a.queryFeatures(o));
+  }
+  const { objectIds: g, attributes: S } = m ? C(a, m, r.timeZone) : { objectIds: void 0, attributes: void 0 };
+  return {
+    tool: "queryFeatures",
+    layerName: f,
+    summary: `${n} features found`,
+    details: {
+      totalCount: n,
+      where: i.where,
+      orderByFields: i.orderByFields,
+      outFields: i.outFields,
+      ...g && { objectIds: g, objectIdField: w },
+      ...S && { attributes: S },
+      ...n > p && {
+        note: `${n} features found.`
+      }
+    }
+  };
+};
+async function k({
+  targetLayer: i,
+  geometryFilter: r,
+  useCurrentExtent: e
+}, l) {
+  const { mapView: a } = N(l, ["mapView"]), d = O(
+    r,
+    l.state?.agentExecutionContext?.sharedResources
+  ), f = await B(i, a, d, e);
+  return JSON.stringify(f, null, 2);
+}
+const D = t.object({
+  layerId: t.string().describe("The layerId of the layer containing the geometry by which to filter."),
+  where: t.string().describe("The SQL-92 where clause representing the features from which to filter."),
+  distance: t.number().optional().describe("The buffer distance around the geometry."),
+  units: q.optional().describe("The units for the distance buffer.")
+}), L = t.object({
+  point: t.object({
+    x: t.number().describe("X coordinate (longitude) from navigation result"),
+    y: t.number().describe("Y coordinate (latitude) from navigation result"),
+    spatialReference: t.object({
+      wkid: t.number().describe("Spatial reference WKID (e.g., 4326 for WGS84)")
+    }).optional().describe("Spatial reference. Defaults to map's spatial reference if not provided.")
+  }).describe("Point coordinates from a previous navigation/geocoding result"),
+  distance: t.number().optional().describe("Optional buffer distance around the point."),
+  units: q.optional().describe("The units for the distance buffer.")
+}), U = t.object({
+  targetLayer: t.object({
+    layerId: t.string().describe("The layerId of the layer containing the field from which to get a value."),
+    where: t.string().describe(
+      "SQL-92 where clause. IMPORTANT: When using geometryFilter.point or geometryFilter.sharedResourceId for point-in-polygon queries, set this to '1=1' to return all features that intersect the point. Only add attribute filters if the user specifically requests them in addition to the spatial query."
+    ),
+    orderByFields: t.array(t.string().describe("The field(s) and order for which to sort the resulting features.")),
+    outFields: t.array(
+      t.string().describe(
+        'The fields to include in the output that will be presented to the user. This should include identifying information about the resulting features, like a name or id, along with the values desired in the output. If unsure, choose all fields ("*").'
+      ).default("*")
+    )
+  }),
+  geometryFilter: t.union([D, L, G]).optional().describe(
+    "Geometry filter for spatial queries. Use 'sharedResourceId' with an ID from listSharedResources for a previously geocoded location. Use 'point' for inline coordinates or 'layerId/where' for features from another layer."
+  ),
+  useCurrentExtent: t.boolean().optional().describe(
+    "Set to true ONLY when user explicitly asks about features 'in my view', 'on my map', 'I am looking at', OR when the user refers back to features previously identified using the current extent (e.g. 'these', 'those', 'them', 'the same ones'). Default is false (queries entire layer)."
+  )
+}), H = v(k, {
+  name: "queryFeatures",
+  description: `Queries features from a layer. Returns the total count of matching features, plus individual feature attributes if ≤25 features match. 
+
+USE THIS TOOL FOR:
+- "Show / display / list features where..." — finding and listing features
+- "How many X are Y?" — counting features that match a condition
+- "Which features..." / "Find features..." — identifying specific features
+- Spatial queries — finding features near/within/intersecting other features
+- Any question where the user wants to SEE or COUNT matching features
+
+This is the DEFAULT tool for most queries. When in doubt, use this tool.`,
+  schema: U
+});
+export {
+  H as queryFeaturesTool
+};

package/dist/agents/tools/search/findRelevantFields/adapter.d.ts

@@ -0,0 +1,8 @@
+import type { StructuredToolInterface } from "@langchain/core/tools";
+
+/**
+ * Finds and enriches fields that are semantically relevant to a task.
+ *
+ * @internal
+ */
+export const findRelevantFieldsTool: StructuredToolInterface;

package/dist/agents/tools/search/findRelevantFields/adapter.js

@@ -0,0 +1,57 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+import { tool as y } from "@langchain/core/tools";
+import t from "zod";
+import { f as h } from "../../../../chunks/fetchAgentContext.js";
+import { f as r } from "../../../../chunks/fetchService.js";
+import { b as p } from "../../../../chunks/fieldStatistics.js";
+const v = 0.7, S = 10;
+async function R(a) {
+  const {
+    query: e,
+    layerIds: i,
+    includeSummaryStatistics: s = !1,
+    fieldSearch: l,
+    layersAndFieldsRegistry: d,
+    embeddingCache: o,
+    mapView: c,
+    minScore: m = v,
+    topResults: f = S
+  } = a, n = await l.searchFields({
+    text: e,
+    layerIds: i,
+    minScore: m,
+    topResults: f,
+    embeddingCache: o
+  }), u = await p(
+    n,
+    d,
+    c,
+    s
+  );
+  return { matches: n, ...u };
+}
+const b = t.object({
+  query: t.string().describe("A concise semantic description of the fields relevant to the user's task."),
+  layerIds: t.array(t.string()).min(1).describe("Layer IDs returned by findRelevantLayers, restricted to layers relevant to the current task."),
+  includeSummaryStatistics: t.boolean().optional().default(!1).describe(
+    "Set to true only when the task directly asks for numeric summaries such as average, minimum, maximum, total, variance, or range."
+  )
+});
+async function F(a, e) {
+  const { mapView: i } = h(e, ["mapView"]), s = await R({
+    ...a,
+    fieldSearch: r(e, "fieldSearch"),
+    layersAndFieldsRegistry: r(e, "layersAndFieldsRegistry"),
+    embeddingCache: r(e, "embeddingCache"),
+    mapView: i
+  });
+  return JSON.stringify(s, null, 2);
+}
+const C = y(F, {
+  name: "findRelevantFields",
+  description: "Finds relevant fields within candidate layers. Returns ranked matches, field metadata, categorical values, and optional numeric summary statistics. Call findRelevantLayers first when layer IDs are not already known.",
+  schema: b
+});
+export {
+  C as findRelevantFieldsTool
+};

package/dist/agents/tools/search/findRelevantLayers/adapter.d.ts

@@ -0,0 +1,8 @@
+import type { StructuredToolInterface } from "@langchain/core/tools";
+
+/**
+ * Finds map layers that are semantically relevant to a task.
+ *
+ * @internal
+ */
+export const findRelevantLayersTool: StructuredToolInterface;