@arcgis/ai-components 5.2.0-next.71 → 5.2.0-next.73

package/dist/chunks/adapter18.js

@@ -0,0 +1,127 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+import { tool as v } from "@langchain/core/tools";
+import { a as C } from "./formatFeatureAttributes.js";
+import { g as O, i as S, a as F, d as I } from "./types.js";
+import { c as j, m as N } from "./mergeWhereClauses.js";
+import t from "zod";
+import { f as R } from "./fetchAgentContext.js";
+const p = 25, x = (i) => i.flatMap((r) => r.split(",")).map((r) => r.trim()).map((r) => r.split(/\s+/u)[0]?.replace(/^"|"$/gu, "")).filter((r) => !!r), W = async (i, r, e, f) => {
+  const a = r.map?.allLayers.find((u) => u.id === i.layerId), l = await r.whenLayerView(a), y = a.title ?? i.layerId;
+  let c;
+  if (e) {
+    const u = await O(e, r);
+    if ("error" in u) {
+      const s = { error: u.error };
+      if (S(e)) {
+        const d = r.map?.allLayers.find((m) => m.id === e.layerId);
+        s.geometryLayerName = d?.title ?? d?.id, s.geometryLayerId = e.layerId, s.geometryWhere = e.where;
+      } else F(e) && (s.point = e.point);
+      return {
+        tool: "queryFeatures",
+        layerName: y,
+        summary: "Geometry lookup failed",
+        details: s
+      };
+    }
+    if (!u.geometry) {
+      const s = {};
+      if (S(e)) {
+        const d = r.map?.allLayers.find((m) => m.id === e.layerId);
+        s.error = `No features found matching: ${e.where}`, s.geometryLayerName = d?.title ?? d?.id, s.geometryLayerId = e.layerId, s.geometryWhere = e.where;
+      } else F(e) && (s.error = "Failed to create point geometry", s.point = e.point);
+      return {
+        tool: "queryFeatures",
+        layerName: y,
+        summary: "No features found for geometry filter",
+        details: s
+      };
+    }
+    c = u.geometry;
+  } else f && (c = r.extent.clone());
+  const T = [
+    .../* @__PURE__ */ new Set([...i.outFields, ...x(i.orderByFields)])
+  ], b = j(l, T, f ?? !1), w = a.objectIdField, o = a.createQuery();
+  o.where = N(a.definitionExpression, i.where || "1=1"), o.outFields = i.outFields.includes("*") ? ["*"] : [.../* @__PURE__ */ new Set([...i.outFields, w])], o.orderByFields = i.orderByFields, c && (o.geometry = c, o.spatialRelationship = "intersects"), e?.distance && (o.distance = e.distance), e?.units && (o.units = e.units), o.outSpatialReference = r.spatialReference;
+  let n, h;
+  try {
+    n = b ? await l.queryFeatureCount(o) : await a.queryFeatureCount(o), n > 0 && n <= p && (h = b ? await l.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 && (h = await a.queryFeatures(o));
+  }
+  const { objectIds: g, attributes: q } = h ? C(a, h, r.timeZone) : { objectIds: void 0, attributes: void 0 };
+  return {
+    tool: "queryFeatures",
+    layerName: y,
+    summary: `${n} features found`,
+    details: {
+      totalCount: n,
+      where: i.where,
+      orderByFields: i.orderByFields,
+      outFields: i.outFields,
+      ...g && { objectIds: g, objectIdField: w },
+      ...q && { attributes: q },
+      ...n > p && {
+        note: `${n} features found.`
+      }
+    }
+  };
+};
+async function B({
+  targetLayer: i,
+  geometryFilter: r,
+  useCurrentExtent: e
+}, f) {
+  const { mapView: a } = R(f, ["mapView"]), l = await W(i, a, r, e);
+  return JSON.stringify(l, null, 2);
+}
+const G = 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.")
+}), k = 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.")
+}), L = 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 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([G, k]).optional().describe(
+    "Geometry filter for spatial queries. Use 'point' option with x/y coordinates from navigation results to find features at that location (point-in-polygon). Use 'layerId/where' option to filter by 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)."
+  )
+}), P = v(B, {
+  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: L
+});
+export {
+  P as queryFeaturesTool
+};

package/dist/chunks/adapter2.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 "./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/chunks/adapter3.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 "./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/chunks/adapter4.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 "./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/chunks/adapter5.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 "./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/chunks/adapter6.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 "./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/chunks/adapter7.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 "./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/chunks/adapter8.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 "./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/chunks/adapter9.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 "./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/chunks/arcgisKnowledgeGraph.js

@@ -1,6 +1,6 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
 import { StateGraph as x, START as k, END as c, Command as b } from "@langchain/langgraph/web";
-import { a as K, c as _, b as T, d as A, e as S, s as M, q as v, g as u, h as q, t as g, r as C, i as E, G, j as m } from "./adapter.js";
+import { a as K, c as _, b as T, d as A, e as S, s as M, q as v, g as u, f as q, t as g, r as C, h as E, G, i as m } from "./adapter.js";
 import "@arcgis/core/identity/IdentityManager.js";
 import "@arcgis/core/portal/Portal.js";
 import "@arcgis/core/request.js";
@@ -130,7 +130,7 @@ const V = (e, t) => (
   //agent services (ex: embeddingsWorker) would go in the array below, if required.
   C([], "ArcgisKnowledge Agent")(e, t)
 );
-async function j(e, t) {
+async function O(e, t) {
   const s = (e.arcgisKnowledgeToolResult ?? []).map((d) => ({
     ...d,
     details: void 0
@@ -154,7 +154,7 @@ async function j(e, t) {
     arcgisKnowledgeMessages: [...e.arcgisKnowledgeMessages, new y(i)]
   };
 }
-async function O(e) {
+async function P(e) {
   const t = e.arcgisKnowledgeToolResult?.[0], o = t?.status === "success" ? t.summary : "ArcGIS Knowledge Agent tool execution failed.";
   return {
     ...e,
@@ -174,7 +174,7 @@ function h(e) {
     }
   })) : await e(t, o);
 }
-const P = () => new x(m).addNode("requireArcgisKnowledgeServices", V).addNode("agent", h(D)).addNode("tools", h(I)).addNode("summarizationLLM", h(j)).addNode("finalizeToolSummary", h(O)).addEdge(k, "requireArcgisKnowledgeServices").addEdge("requireArcgisKnowledgeServices", "agent").addConditionalEdges("agent", (t) => (t.arcgisKnowledgeMessages[t.arcgisKnowledgeMessages.length - 1]?.tool_calls?.length ?? 0) > 0 ? "tools" : c).addConditionalEdges("tools", (t) => {
+const j = () => new x(m).addNode("requireArcgisKnowledgeServices", V).addNode("agent", h(D)).addNode("tools", h(I)).addNode("summarizationLLM", h(O)).addNode("finalizeToolSummary", h(P)).addEdge(k, "requireArcgisKnowledgeServices").addEdge("requireArcgisKnowledgeServices", "agent").addConditionalEdges("agent", (t) => (t.arcgisKnowledgeMessages[t.arcgisKnowledgeMessages.length - 1]?.tool_calls?.length ?? 0) > 0 ? "tools" : c).addConditionalEdges("tools", (t) => {
   if (t.status === "failed")
     return c;
   const o = t.arcgisKnowledgeToolResult?.[0];
@@ -221,7 +221,7 @@ _example: "What is the average age of all people who work for Esri?"_`, le = {
   id: "arcgisKnowledge",
   name: "ArcgisKnowledge Agent",
   description: J,
-  createGraph: P,
+  createGraph: j,
   workspace: m
 };
 export {

package/dist/chunks/baseAgentState.js

@@ -0,0 +1,56 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+import { Annotation as s } from "@langchain/langgraph/web";
+const n = (e, t) => t, c = (e, t) => ({
+  ...e,
+  ...t
+}), o = (e = "", t) => {
+  const r = typeof t == "string" ? t.trim() : "";
+  if (!r)
+    return e;
+  const a = e.trim();
+  if (!a)
+    return r;
+  if (a === r)
+    return e;
+  const u = a.split(`
+
+`);
+  return u[u.length - 1]?.trim() === r ? e : `${e}
+
+${r}`;
+}, i = () => ({
+  userRequest: "",
+  assignedTask: "",
+  messages: [],
+  priorSteps: [],
+  sharedState: {}
+}), d = () => ({
+  agentExecutionContext: s({
+    reducer: c,
+    default: i
+  }),
+  outputMessage: s({
+    reducer: o,
+    default: () => ""
+  }),
+  summary: s({
+    reducer: n,
+    default: () => ""
+  }),
+  status: s({
+    reducer: n
+  })
+}), g = () => ({
+  ...d(),
+  sharedStatePatch: s({
+    reducer: n
+  })
+});
+export {
+  d as a,
+  g as b,
+  i as c,
+  o as d,
+  c as m,
+  n as r
+};