@arcgis/ai-components 5.2.0-next.9 → 5.2.0-next.91

package/dist/agents/tools/filter/resetMap/adapter.d.ts

@@ -0,0 +1,8 @@
+import type { StructuredToolInterface } from "@langchain/core/tools";
+
+/**
+ * Clears all feature effects and returns the map to its initial viewpoint.
+ *
+ * @internal
+ */
+export const resetMapTool: StructuredToolInterface;

package/dist/agents/tools/filter/resetMap/adapter.js

@@ -0,0 +1,22 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+import { tool as n } from "@langchain/core/tools";
+import i from "zod";
+import { f as l } from "../../../../chunks/fetchAgentContext.js";
+const f = async (e) => {
+  e.map?.allLayers.filter((t) => t.type === "feature")?.forEach((t) => {
+    const s = t;
+    s.featureEffect && (s.featureEffect = null);
+  });
+  const o = e.map.initialViewProperties?.viewpoint?.targetGeometry;
+  return o ? (await e.goTo(o), "Cleared all filters and returned to home extent.") : "Cleared all filters. Could not determine home extent.";
+}, p = async (e, r) => {
+  const { mapView: a } = l(r, ["mapView"]);
+  return await f(a);
+}, h = n(p, {
+  name: "resetMap",
+  description: "Clears all feature effects/filters from the map AND zooms to the home extent (initial map view). Use when user says 'reset map', 'reset the map', 'start over', or wants to both clear filters and return to the initial view.",
+  schema: i.object({})
+});
+export {
+  h as resetMapTool
+};

package/dist/agents/tools/filter/setFeatureEffect/adapter.d.ts

@@ -0,0 +1,8 @@
+import type { StructuredToolInterface } from "@langchain/core/tools";
+
+/**
+ * Applies include and exclude effects to layer features with optional spatial filtering.
+ *
+ * @internal
+ */
+export const setFeatureEffectTool: StructuredToolInterface;

package/dist/agents/tools/filter/setFeatureEffect/adapter.js

@@ -0,0 +1,109 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+import e from "zod";
+import { tool as h } from "@langchain/core/tools";
+import m from "@arcgis/core/layers/support/FeatureEffect.js";
+import b from "@arcgis/core/layers/support/FeatureFilter.js";
+import { g as y, d } from "../../../../chunks/types.js";
+import { f as w } from "../../../../chunks/fetchAgentContext.js";
+const g = async (t, o, u, n, r, c) => {
+  const a = t.map?.allLayers.find((i) => i.id === o);
+  if (!a)
+    return { success: !1, error: `Layer '${o}' not found.` };
+  const s = a.createQuery();
+  s.where = u ?? "1=1", n && (s.geometry = n, s.spatialRelationship = "intersects", r && (s.distance = r), c && (s.units = c));
+  try {
+    const { extent: i, count: l } = await a.queryExtent(s);
+    return !i || l === 0 ? {
+      success: !1,
+      error: `No features found for filter (where: ${s.where}${n ? ", spatial filter used" : ""})`
+    } : (await t.goTo(i), { success: !0 });
+  } catch (i) {
+    return {
+      success: !1,
+      error: i instanceof Error ? i.message : String(i)
+    };
+  }
+}, I = async (t, o, u, n, r, c) => {
+  const a = o.map?.allLayers.find(
+    (f) => f.id === t.layerId
+  );
+  if (!a)
+    return `Could not find target layer with ID: ${t.layerId}`;
+  let s;
+  if (r) {
+    const f = await y(r, o);
+    if ("error" in f)
+      return f.error;
+    s = f.geometry;
+  }
+  if (a.featureEffect = null, a.featureEffect = new m({
+    filter: new b({
+      ...t.objectIds?.length ? { objectIds: t.objectIds } : { where: t.where },
+      geometry: s,
+      spatialRelationship: "intersects",
+      distance: r?.distance,
+      units: r?.units
+    }),
+    includedEffect: u,
+    excludedEffect: n
+  }), a.visible = !0, c)
+    return `Applied feature effects to "${a.title ?? t.layerId}" within current map extent.`;
+  const i = t.objectIds?.length ? `${a.objectIdField} IN (${t.objectIds.join(",")})` : t.where, l = await g(
+    o,
+    t.layerId,
+    i,
+    s,
+    r?.distance,
+    r?.units
+  ), p = a.title ?? t.layerId;
+  return l.success ? `Applied feature effects to target layer "${a.title ?? t.layerId}"${r && "layerId" in r ? ` using geometry from layer "${r.layerId}"` : ""}.` : `Applied filter to "${p}" but no features matched. ${l.error}`;
+}, v = async ({
+  targetLayer: t,
+  geometryFilter: o,
+  useCurrentExtent: u,
+  includedEffect: n = "drop-shadow(2px, 2px, 2px, gray)",
+  excludedEffect: r = "grayscale(100%) opacity(60%) blur(2px)"
+}, c) => {
+  const { mapView: a } = w(c, ["mapView"]);
+  return await I(t, a, n, r, o, u);
+}, x = 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: d.optional().describe("The units for the distance buffer.")
+}), j = 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: d.optional().describe("The units for the distance buffer.")
+}), E = e.object({
+  targetLayer: e.object({
+    layerId: e.string().describe("The layerId of the layer on which to set a feature effect."),
+    where: e.string().describe("The SQL-92 where clause representing the features to emphasize."),
+    objectIds: e.array(e.number()).optional().describe(
+      "Array of objectIds from a previous query result. Use this instead of a where clause when the query returned objectIds (e.g. top N results). If provided, takes precedence over where clause."
+    )
+  }),
+  geometryFilter: e.union([x, j]).optional().describe("Optional geometry-based filtering parameters for spatial queries."),
+  useCurrentExtent: e.boolean().optional().describe(
+    "Set to true when the previous query used the current map extent as a spatial filter. This ensures the feature effect applies only to features visible in the current view. Default is false."
+  ),
+  includedEffect: e.string().default("drop-shadow(2px, 2px, 2px, gray)").describe(
+    "The effect applied to features that meet the filter requirements. Valid effects include: bloom, blur, brightness, contrast, drop-shadow, grayscale, hue-rotate, invert, opacity, saturate, and sepia. Prefer default unless specified."
+  ),
+  excludedEffect: e.string().default("grayscale(100%) opacity(60%) blur(2px)").describe(
+    "The effect applied to features that do not meet the filter requirements. Valid effects include: bloom, blur, brightness, contrast, drop-shadow, grayscale, hue-rotate, invert, opacity, saturate, and sepia. Prefer default unless specified."
+  )
+}), A = h(v, {
+  name: "setFeatureEffect",
+  description: "Sets a feature effect on a given layer with given filter parameters and feature effects to emphasize certain features that meet a filter requirement. If no feature effect information is provided, then use the default effect provided.",
+  schema: E
+});
+export {
+  A as setFeatureEffectTool
+};

package/dist/agents/tools/help/listFields/adapter.d.ts

@@ -0,0 +1,11 @@
+import type { StructuredToolInterface } from "@langchain/core/tools";
+
+/**
+ * Lists registered fields for a user-specified layer.
+ *
+ * Use only when the user explicitly requests fields, columns, or attributes
+ * for a named layer.
+ *
+ * @internal
+ */
+export const listLayerFieldsTool: StructuredToolInterface;

package/dist/agents/tools/help/listFields/adapter.js

@@ -0,0 +1,30 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+import { tool as n } from "@langchain/core/tools";
+import s from "zod";
+import { f as c } from "../../../../chunks/fetchService.js";
+const y = (i, r) => {
+  const t = Array.from(i.values()).find(
+    ({ layerItem: e }) => e.title?.toLowerCase().includes(r.toLowerCase())
+  );
+  if (!t) {
+    const e = Array.from(i.values()).map((o) => o.layerItem.title).join(", ");
+    return `Could not find a layer matching "${r}". Available layers: ${e}`;
+  }
+  const l = Array.from(t.fieldRegistry.values()), a = l.map((e) => `- **${e.alias || e.name}** (\`${e.name}\`, ${e.type})${e.description ? `: ${e.description}` : ""}`).join(`
+`);
+  return `**${t.layerItem.title}** has ${l.length} field(s):
+
+${a}`;
+}, d = ({ layerTitle: i }, r) => {
+  const t = c(r, "layersAndFieldsRegistry");
+  return y(t, i);
+}, u = n(d, {
+  name: "listLayerFields",
+  description: "Lists all fields for a given layer by title. Use ONLY when the user explicitly asks to see fields, columns, or attributes of a specific named layer. Do NOT call this tool for general help questions, capability overviews, or layer listing.",
+  schema: s.object({
+    layerTitle: s.string().describe("The title or partial title of the layer to list fields for.")
+  })
+});
+export {
+  u as listLayerFieldsTool
+};

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

@@ -0,0 +1,10 @@
+import type { StructuredToolInterface } from "@langchain/core/tools";
+
+/**
+ * A tool that geocodes an address or place name and navigates the map to the result.
+ * It uses the map view provided by the agent's runtime context.
+ *
+ * @internal
+ * @since 5.2
+ */
+export const goToAddressTool: StructuredToolInterface;

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

@@ -0,0 +1,52 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+import { tool as p } from "@langchain/core/tools";
+import r from "@arcgis/core/config.js";
+import f from "@arcgis/core/Graphic.js";
+import u from "@arcgis/core/portal/Portal.js";
+import { addressToLocations as S } from "@arcgis/core/rest/locator.js";
+import v from "@arcgis/core/symbols/PictureMarkerSymbol.js";
+import { f as w } from "../../../../chunks/fetchAgentContext.js";
+import c from "zod";
+async function y(e, t) {
+  const a = u.getDefault().helperServices, n = a.geocode.find((h) => h.name === "ArcGIS World Geocoding Service") ?? a.geocode[0];
+  if (!n)
+    throw new Error("No geocoding service found in helperServices.");
+  const i = n.url, d = `${r.assetsPath?.endsWith("/") ? r.assetsPath : `${r.assetsPath}/`}esri/images/search/search-symbol-32.png`, o = (await S(i, {
+    address: { SingleLine: e },
+    outFields: ["Match_addr"]
+  }))?.[0];
+  if (!o?.extent || !o.location)
+    throw new Error(`Could not find location for: ${e}`);
+  const l = new v({
+    url: d,
+    width: 24,
+    height: 24
+  }), m = new f({
+    geometry: o.location,
+    symbol: l
+  });
+  t.graphics.removeAll(), t.graphics.add(m), await t.goTo(o.extent);
+  const g = {
+    address: o.address ?? "",
+    location: o.location ? o.location.toJSON() : null,
+    extent: o.extent ? o.extent.toJSON() : null
+  };
+  return {
+    text: `Successfully zoomed to ${e}.`,
+    sharedStatePatch: { lastResolvedLocation: { value: g } }
+  };
+}
+async function T({ address: e }, t) {
+  const { mapView: s } = w(t, ["mapView"]);
+  return await y(e, s);
+}
+const x = c.object({
+  address: c.string().describe("The full address or place name to locate.")
+}), E = p(T, {
+  name: "goToAddress",
+  description: "Geocodes an address using Esri's World Geocoding Service and zooms the map to that location.",
+  schema: x
+});
+export {
+  E as goToAddressTool
+};

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

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

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

@@ -0,0 +1,30 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+import { z as i } from "zod";
+import { tool as k } from "@langchain/core/tools";
+import { f as s } from "../../../../chunks/fetchAgentContext.js";
+async function c(o, t) {
+  const e = t.map.bookmarks;
+  if (!e || e.length === 0)
+    throw new Error("No bookmarks found in the map.");
+  const n = e.find((m) => m.name === o);
+  if (!n)
+    throw new Error(`Bookmark with name "${o}" not found.`);
+  const a = n.viewpoint;
+  if (!a)
+    throw new Error(`Bookmark with name "${o}" does not have a valid viewpoint.`);
+  return await t.goTo(a), { text: `Navigated to bookmark: ${o}` };
+}
+async function h({ bookmarkName: o }, t) {
+  const { mapView: r } = s(t, ["mapView"]);
+  return await Promise.resolve(c(o, r));
+}
+const w = i.object({
+  bookmarkName: i.string().describe("The name of the bookmark to navigate to.")
+}), b = k(h, {
+  name: "goToBookmark",
+  description: "Go to the extent of the bookmark with the given name.",
+  schema: w
+});
+export {
+  b as goToBookmarkTool
+};

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

@@ -0,0 +1,8 @@
+import type { StructuredToolInterface } from "@langchain/core/tools";
+
+/**
+ * Navigates to features that match a layer and SQL where clause.
+ *
+ * @internal
+ */
+export const goToFeaturesTool: StructuredToolInterface;

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

@@ -0,0 +1,50 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+import { z as i } from "zod";
+import { tool as u } from "@langchain/core/tools";
+import { f as c } from "../../../../chunks/fetchAgentContext.js";
+async function f(o, a, n) {
+  const e = n.map?.allLayers.find((r) => r.id === o);
+  if (!e)
+    return { text: `Error: Layer with id ${o} not found` };
+  const t = a?.trim() ? a : "1=1", l = e.createQuery();
+  l.where = t;
+  try {
+    const { extent: r, count: s } = await e.queryExtent(l);
+    if (s === 0)
+      return { text: `No features found in ${e.title} matching: ${t}`, where: t };
+    if (r)
+      await n.goTo(r);
+    else
+      return { text: `Error: Unable to determine extent for ${e.title}`, where: t };
+    const d = {
+      layerId: o,
+      layerTitle: e.title ?? o,
+      where: t,
+      count: s
+    };
+    return {
+      text: `Successfully zoomed to ${s} feature(s) in ${e.title} matching: ${t}`,
+      where: t,
+      sharedStatePatch: { lastNavigatedFeatures: { value: d } }
+    };
+  } catch (r) {
+    return console.error("Error in goToFeatures:", r), { text: `Error: ${r instanceof Error ? r.message : "Unknown error"}`, where: t };
+  }
+}
+async function h({ layerId: o, where: a }, n) {
+  const { mapView: e } = c(n, ["mapView"]);
+  return await f(o, a, e);
+}
+const m = i.object({
+  layerId: i.string().describe("The layerId of the layer to zoom to."),
+  where: i.string().describe(
+    "ArcGIS SQL-92 WHERE expression used for `query.where` on the selected layer. Start with a fresh filter for the current request unless the task explicitly refers to prior results. Use only field name values from the selected layer, not aliases. Use field metadata only to interpret intent: prefer LIKE '%value%' for string fields, and use =, <, >, BETWEEN, IN, IS NULL, AND/OR/NOT as appropriate for number/date fields. For coded-value domain fields, use the domain code already provided in layerInfo.domain.codedValues, never the display label. Respect range-domain bounds when they are provided. Do NOT include subqueries, nested SELECT, JOIN, GROUP BY, HAVING, ORDER BY, or semicolons."
+  )
+}), E = u(h, {
+  name: "goToFeatures",
+  description: "Go to the features that match the given filter for the given layerId. Use coded-value domain codes from layer field metadata when building the WHERE clause.",
+  schema: m
+});
+export {
+  E as goToFeaturesTool
+};

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

@@ -0,0 +1,8 @@
+import type { StructuredToolInterface } from "@langchain/core/tools";
+
+/**
+ * Navigates the map to the full world extent.
+ *
+ * @internal
+ */
+export const goToFullExtentTool: StructuredToolInterface;

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

@@ -0,0 +1,27 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+import { z as n } from "zod";
+import r from "@arcgis/core/geometry/Extent.js";
+import { tool as i } from "@langchain/core/tools";
+import { f as l } from "../../../../chunks/fetchAgentContext.js";
+async function m(o) {
+  const t = new r({
+    xmin: -180,
+    ymin: -90,
+    xmax: 180,
+    ymax: 90,
+    spatialReference: { wkid: 4326 }
+  }).expand(0.7);
+  return await o.goTo(t), { text: "Successfully zoomed to world extent" };
+}
+async function a(o, e) {
+  const { mapView: t } = l(e, ["mapView"]);
+  return await m(t);
+}
+const c = n.object({}), f = i(a, {
+  name: "goToFullExtent",
+  description: "Zooms the map to the full world extent using Esri's Geocoding Service.",
+  schema: c
+});
+export {
+  f as goToFullExtentTool
+};

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

@@ -0,0 +1,8 @@
+import type { StructuredToolInterface } from "@langchain/core/tools";
+
+/**
+ * Returns the map to its initial viewpoint.
+ *
+ * @internal
+ */
+export const goToHomeExtentTool: StructuredToolInterface;

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

@@ -0,0 +1,24 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+import { tool as n } from "@langchain/core/tools";
+import i from "zod";
+import { f as r } from "../../../../chunks/fetchAgentContext.js";
+async function a(e) {
+  const t = e.map.initialViewProperties?.viewpoint?.targetGeometry;
+  if (t)
+    await e.goTo(t);
+  else
+    throw new Error("Initial extent is undefined");
+  return { text: "Successfully zoomed to home extent" };
+}
+async function m(e, o) {
+  const { mapView: t } = r(o, ["mapView"]);
+  return await a(t);
+}
+const c = i.object({}), w = n(m, {
+  name: "goToHomeExtent",
+  description: "Go to the initial web map view extent",
+  schema: c
+});
+export {
+  w as goToHomeExtentTool
+};

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

@@ -0,0 +1,8 @@
+import type { StructuredToolInterface } from "@langchain/core/tools";
+
+/**
+ * Navigates to the full extent of a layer.
+ *
+ * @internal
+ */
+export const goToLayerTool: StructuredToolInterface;

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

@@ -0,0 +1,26 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+import { z as r } from "zod";
+import { tool as i } from "@langchain/core/tools";
+import { f as c } from "../../../../chunks/fetchAgentContext.js";
+async function l(o, t) {
+  await t.when();
+  const e = t.map?.allLayers.find((n) => n.id === o);
+  if (!e)
+    return console.warn(`[goToLayer] No matching FeatureLayer found for: ${o}`), { text: `Could not find layer for: ${o}` };
+  let a;
+  return (e.type === "link-chart" || e.type === "knowledge-graph-sublayer") && t.map?.activeLinkChartLayer ? a = t.map.diagramNodesExtent : a = e.fullExtent, a ? (await t.goTo(a), e.visible = !0, { text: `Successfully zoomed to: ${e.title ?? ""}` }) : { text: "Layer has no defined extent. Cannot zoom to layer." };
+}
+async function f({ layerId: o }, t) {
+  const { mapView: e } = c(t, ["mapView"]);
+  return await l(o, e);
+}
+const s = r.object({
+  layerId: r.string().describe("The id of the layer to navigate to")
+}), h = i(f, {
+  name: "goToLayer",
+  description: "Zooms the map view to the full extent of the top matching layer.",
+  schema: s
+});
+export {
+  h as goToLayerTool
+};

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

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

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

@@ -0,0 +1,21 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+import t from "zod";
+import { tool as a } from "@langchain/core/tools";
+import { f as i } from "../../../../chunks/fetchAgentContext.js";
+async function n(o, e) {
+  return await e.goTo({ scale: o }), { text: `Successfully zoomed to: ${o}` };
+}
+async function r({ scale: o }, e) {
+  const { mapView: c } = i(e, ["mapView"]);
+  return await n(o, c);
+}
+const m = t.object({
+  scale: t.number().describe("The map scale of the view to go to.")
+}), f = a(r, {
+  name: "goToScale",
+  description: "Go to the specified view scale.",
+  schema: m
+});
+export {
+  f as goToScaleTool
+};

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

@@ -0,0 +1,8 @@
+import type { StructuredToolInterface } from "@langchain/core/tools";
+
+/**
+ * Navigates to a center point with optional zoom and scale values.
+ *
+ * @internal
+ */
+export const goToViewpointTool: StructuredToolInterface;

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;