@arcgis/ai-components 5.2.0-next.11 → 5.2.0-next.110

package/dist/utils/index.js

@@ -1,55 +1,86 @@
-/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
-import { g as p } from "../chunks/orchestrator.js";
-import { O as ue } from "../chunks/orchestrator.js";
-import { s as h, a as A } from "../chunks/index.js";
-import { g as S, a as v, W as w, f, l as y, d as $, m as b, b as E, s as L, i as P, e as M, h as T, j as R, k, c as x } from "../chunks/generateLayerDescriptions.js";
-import D from "@arcgis/core/layers/FeatureLayer.js";
-import * as W from "@arcgis/core/core/reactiveUtils.js";
-import { N as F } from "../chunks/navigationGraph.js";
-import { L as C } from "../chunks/layerStylingGraph.js";
-import { D as N } from "../chunks/dataExplorationGraph.js";
-import { H as z } from "../chunks/helpGraph.js";
-import { A as H } from "../chunks/arcgisKnowledgeGraph.js";
-const I = async (e) => {
-  const t = e.allLayers.toArray(), s = [], o = /* @__PURE__ */ new Map();
-  for (const a of t)
-    if (a instanceof D) {
-      const m = (async () => {
-        const r = await S(a), n = await v(a, r);
-        o.set(a.id, { layerItem: n, fieldRegistry: r });
+/* COPYRIGHT Esri - https://js.arcgis.com/1.0/LICENSE.txt */
+import { g as q } from "../chunks/orchestrator.js";
+import { O as fa } from "../chunks/orchestrator.js";
+import { s as d, a as Q } from "../chunks/index.js";
+import { c as B, d as J, W as U, f as _, l as I, e as K, m as X, h as Y, s as ee, i as v, j as D, a as z } from "../chunks/generateLayerDescriptions.js";
+import { c as te } from "../chunks/aiFactory.js";
+import ae from "@arcgis/core/layers/FeatureLayer.js";
+import * as oe from "@arcgis/core/core/reactiveUtils.js";
+import { a as se, d as re } from "../chunks/baseAgentState.js";
+import { N as ne } from "../chunks/navigationAgent.js";
+import { StateGraph as T, START as b, END as x } from "@langchain/langgraph/web";
+import { e as S, t as E, N as G, x as P, y as ie, D as V, z as le, H } from "../chunks/adapter.js";
+import "@arcgis/core/identity/IdentityManager.js";
+import "@arcgis/core/portal/Portal.js";
+import "@arcgis/core/request.js";
+import "@arcgis/toolkit/string";
+import { AIMessage as ce } from "@langchain/core/messages";
+import "@langchain/core/callbacks/dispatch/web";
+import "@langchain/core/callbacks/base";
+import "@langchain/openai";
+import "@arcgis/core/config.js";
+import { goToAddressTool as de } from "../agents/tools/navigation/goToAddress/adapter.js";
+import { goToBookmarkTool as me } from "../agents/tools/navigation/goToBookmark/adapter.js";
+import { goToFeaturesTool as pe } from "../agents/tools/navigation/goToFeatures/adapter.js";
+import { goToFullExtentTool as ge } from "../agents/tools/navigation/goToFullExtent/adapter.js";
+import { goToHomeExtentTool as ue } from "../agents/tools/navigation/goToHomeExtent/adapter.js";
+import { goToLayerTool as he } from "../agents/tools/navigation/goToLayer/adapter.js";
+import { goToScaleTool as ye } from "../agents/tools/navigation/goToScale/adapter.js";
+import { goToViewpointTool as fe } from "../agents/tools/navigation/goToViewpoint/adapter.js";
+import { goToZoomTool as xe } from "../agents/tools/navigation/goToZoom/adapter.js";
+import { f as $ } from "../chunks/fetchAgentContext.js";
+import { h as w, L as Se } from "../chunks/layerStylingGraph.js";
+import "@langchain/core/prompts";
+import { ToolNode as M } from "@langchain/langgraph/prebuilt";
+import k from "zod";
+import { f as u } from "../chunks/fetchService.js";
+import { r as L } from "../chunks/requireAgentServices.js";
+import { D as ve } from "../chunks/dataExplorationAgent.js";
+import { b as j } from "../chunks/formatFeatureAttributes.js";
+import { b as Ee } from "../chunks/fieldStatistics.js";
+import { H as we } from "../chunks/helpAgent.js";
+import { listLayerFieldsTool as Te } from "../agents/tools/help/listFields/adapter.js";
+import { A as be } from "../chunks/arcgisKnowledgeGraph.js";
+const $e = async (e) => {
+  const t = e.allLayers.toArray(), a = [], o = /* @__PURE__ */ new Map();
+  for (const n of t)
+    if (n instanceof ae) {
+      const s = (async () => {
+        const r = await B(n), l = await J(n, r);
+        o.set(n.id, { layerItem: l, fieldRegistry: r });
       })();
-      s.push(m);
+      a.push(s);
     }
-  return await Promise.all(s), o;
-}, O = async (e) => {
-  await W.whenOnce(() => e.ready);
-  const t = await I(e.map), { layers: s } = await U(t), o = {
-    schemaVersion: L,
+  return await Promise.all(a), o;
+}, Me = async (e) => {
+  await oe.whenOnce(() => e.ready);
+  const t = await $e(e.map), { layers: a } = await Le(t), o = {
+    schemaVersion: ee,
     modified: Date.now(),
     embeddings: {
-      modelProvider: E,
-      model: b,
-      dimensions: $,
+      modelProvider: Y,
+      model: X,
+      dimensions: K,
       templates: {
-        layer: y,
-        field: f
+        layer: I,
+        field: _
       }
     },
-    layers: s
-  }, a = w.safeParse(o);
-  if (!a.success)
-    throw console.error("Schema Mismatch:", a.error.format()), new Error("Webmap embedding generation failed validation.");
-  return a.data;
-}, U = async (e) => {
-  const t = [], s = [];
-  for (const [r, { fieldRegistry: n, layerItem: i }] of e.entries()) {
-    const l = g(y, {
+    layers: a
+  }, n = U.safeParse(o);
+  if (!n.success)
+    throw console.error("Schema Mismatch:", n.error.format()), new Error("Webmap embedding generation failed validation.");
+  return n.data;
+}, Le = async (e) => {
+  const t = [], a = [];
+  for (const [r, { fieldRegistry: l, layerItem: i }] of e.entries()) {
+    const c = C(I, {
       name: i.name,
       title: i.title,
       description: i.description
     });
-    t.push(l);
-    const d = {
+    t.push(c);
+    const m = {
       id: r,
       name: i.name ?? "",
       title: i.title,
@@ -57,60 +88,653 @@ const I = async (e) => {
       vector: [],
       fields: []
     };
-    for (const [, c] of n.entries()) {
-      const u = g(f, {
-        name: c.name,
-        alias: c.alias,
-        description: c.description
+    for (const [, g] of l.entries()) {
+      const p = C(_, {
+        name: g.name,
+        alias: g.alias,
+        description: g.description
       });
-      t.push(u), d.fields.push({
-        name: c.name,
-        alias: c.alias,
-        description: c.description,
+      t.push(p), m.fields.push({
+        name: g.name,
+        alias: g.alias,
+        description: g.description,
         vector: []
       });
     }
-    s.push(d);
+    a.push(m);
   }
-  const o = await p(t);
-  let a = 0;
-  return { layers: s.map((r) => (r.vector = o[a++], r.fields.forEach((n) => {
-    n.vector = o[a++];
+  const o = await q(t);
+  let n = 0;
+  return { layers: a.map((r) => (r.vector = o[n++], r.fields.forEach((l) => {
+    l.vector = o[n++];
   }), r)) };
-}, g = (e, t) => e.replace(/\{(\w+)\}/gu, (s, o) => t[o] ?? ""), V = (e, t) => {
+}, C = (e, t) => e.replace(/\{(\w+)\}/gu, (a, o) => t[o] ?? ""), Re = (e, t) => {
   if (e.length !== t.length)
     throw new Error("Vectors must be the same length");
-  let s = 0, o = 0, a = 0;
-  for (let n = 0; n < e.length; ++n) {
-    const i = e[n], l = t[n];
-    s += i * l, o += i * i, a += l * l;
+  let a = 0, o = 0, n = 0;
+  for (let l = 0; l < e.length; ++l) {
+    const i = e[l], c = t[l];
+    a += i * c, o += i * i, n += c * c;
   }
-  const m = Math.sqrt(o * a);
-  if (m === 0)
+  const s = Math.sqrt(o * n);
+  if (s === 0)
     return 0;
-  const r = s / m;
+  const r = a / s;
   return Math.max(-1, Math.min(1, r));
-}, Y = M, Z = P, ee = T, te = h, ae = p, se = V, oe = F, re = C, ne = N, ie = z, ce = H, me = O, le = () => R(), de = () => k(), ge = async (e, t) => await A(e, t), pe = async ({
+}, R = [
+  de,
+  me,
+  pe,
+  ge,
+  ue,
+  he,
+  ye,
+  fe,
+  xe
+];
+async function ke(e, t) {
+  const a = await S("navigation_tool_prompt"), { mapView: o } = $(t, ["mapView"]), s = o.map.bookmarks?.map((f) => f.name).filter(Boolean) ?? [], r = e.vectorSearchLayerResults?.length > 0 ? e.vectorSearchLayerResults.map(
+    (f, Z) => `${Z + 1}. layerId=${f.id} | title=${f.title ?? ""} | name=${f.name ?? ""} | score=${f.score.toFixed(2)}`
+  ).join(`
+`) : "", l = e.vectorSearchFieldResults?.length > 0 ? JSON.stringify(e.vectorSearchFieldResults, null, 2) : "", i = e.intent === "goToBookmark" && s.length ? `Available bookmarks:
+${s.map((f) => `- ${f}`).join(`
+`)}` : "", c = (e.intent === "goToLayer" || e.intent === "goToFeatures") && e.vectorSearchLayerResults?.length ? `Candidate layers:
+${r}` : "", m = e.intent === "goToFeatures" && e.vectorSearchFieldResults?.length ? `Candidate fields:
+${l}` : "", g = {
+    intent: e.intent,
+    bookmarksSection: i,
+    layersSection: c,
+    fieldsSection: m,
+    currentZoom: o.zoom,
+    assignedTask: e.agentExecutionContext.assignedTask,
+    userRequest: e.agentExecutionContext.userRequest,
+    priorSteps: e.agentExecutionContext.priorSteps
+  }, p = await v({
+    promptText: a,
+    modelTier: "fast",
+    config: t,
+    inputVariables: g,
+    tools: R
+  });
+  await w(p, t);
+  const h = (p.tool_calls?.length ?? 0) > 0, y = typeof p.text == "string" ? p.text.trim() : "", W = y.length > 0;
+  return {
+    ...e,
+    navigationInternalState: {
+      ...e.navigationInternalState,
+      toolCallMessage: h ? p : void 0
+    },
+    // No tool call => surface fallback text now. Tool call => tool node will set output.
+    outputMessage: h ? e.outputMessage : y,
+    status: h ? e.status : W ? "success" : "failed"
+  };
+}
+const Ce = (e) => {
+  const t = typeof e == "string" ? e : String(e);
+  try {
+    const a = JSON.parse(t);
+    if (a && typeof a == "object" && typeof a.text == "string")
+      return a;
+  } catch {
+    console.warn("Failed to parse tool response as JSON:", t);
+  }
+  return { text: t };
+};
+async function Ae(e, t) {
+  const a = new M(R, { handleToolErrors: !1 });
+  try {
+    const o = e.navigationInternalState.toolCallMessage;
+    if (!o)
+      throw new Error("navigationToolCalling: missing navigationInternalState.toolCallMessage");
+    const { messages: n } = await a.invoke(
+      {
+        messages: [o]
+      },
+      t
+    );
+    let s = "", r, l;
+    for (const i of n) {
+      const c = Ce(i.content), m = i.artifact;
+      c.text && (s += `${c.text}
+`);
+      const g = m?.sharedStatePatch ?? c.sharedStatePatch;
+      g && (r = {
+        ...r,
+        ...g
+      }), m?.sharedResourceAdditions && (l = [...l ?? [], ...m.sharedResourceAdditions]);
+    }
+    return await d({ text: `Finished executing navigation tool: ${s}` }, t), {
+      ...e,
+      outputMessage: s,
+      sharedStatePatch: r,
+      sharedResourceAdditions: l,
+      status: "success",
+      summary: s ? E(s) : "Navigation executed.",
+      navigationInternalState: {
+        ...e.navigationInternalState,
+        toolCallMessage: void 0
+      }
+    };
+  } catch (o) {
+    const n = o instanceof Error ? o.message : String(o);
+    return await d({ text: `Navigation tool execution failed: ${n}` }, t), {
+      ...e,
+      outputMessage: `Navigation tool execution failed: ${n}`,
+      status: "failed",
+      summary: `Navigation tool execution failed: ${n}`,
+      navigationInternalState: {
+        ...e.navigationInternalState,
+        toolCallMessage: void 0
+      }
+    };
+  }
+}
+async function Fe(e, t) {
+  const a = await S("navigation_intent_prompt"), { mapView: o } = $(t, ["mapView"]), n = R.map((p) => ({
+    name: p.name,
+    description: p.description,
+    schema: p.schema
+  })), r = o.map.bookmarks?.map((p) => p.name).filter(Boolean) ?? [], l = r.length ? `Available bookmarks:
+${r.map((p) => `- ${p}`).join(`
+`)}` : "No bookmarks are available in this map.", i = {
+    tools: n.map(({ name: p, description: h, schema: y }) => `${p}: ${h}, ${JSON.stringify(y)}`).join(`
+`),
+    bookmarks: l,
+    assignedTask: e.agentExecutionContext.assignedTask,
+    userRequest: e.agentExecutionContext.userRequest,
+    priorSteps: e.agentExecutionContext.priorSteps
+  }, c = k.object({
+    intent: k.string()
+  }), m = await D({
+    promptText: a,
+    config: t,
+    inputVariables: i,
+    schema: c,
+    modelTier: "fast"
+  }), g = typeof m.intent == "string" ? m.intent.trim().replace(/^"|"$/gu, "") : "";
+  return { ...e, intent: g || "" };
+}
+const Ne = 0.7, qe = async (e, t) => {
+  try {
+    await d(
+      { text: `Similarity search to find layers: ${e.agentExecutionContext.assignedTask}` },
+      t
+    );
+    const a = u(t, "layerSearch"), o = u(t, "layersAndFieldsRegistry"), n = u(t, "embeddingCache"), r = (await a.searchLayers({
+      text: e.agentExecutionContext.assignedTask,
+      minScore: Ne,
+      embeddingCache: n
+    })).map(({ id: i, score: c }) => {
+      const m = o.get(i)?.layerItem;
+      return {
+        id: i,
+        title: m?.title,
+        name: m?.name ?? void 0,
+        score: c
+      };
+    });
+    let l;
+    return r.length > 0 ? l = `Vector search completed. Matching layers:
+${r.map((i) => `- layerId=${i.id} | title=${i.title ?? ""} | name=${i.name ?? ""} | score=${i.score.toFixed(2)}`).join(`
+`)}` : l = "Vector search completed. No matching layers found.", await d({ text: l }, t), {
+      ...e,
+      vectorSearchLayerResults: r
+    };
+  } catch (a) {
+    throw await d(
+      { text: `Error during vector search layers: ${a instanceof Error ? a.message : String(a)}` },
+      t
+    ), a;
+  }
+}, A = 0.7, _e = 10, Ie = async (e, t) => {
+  try {
+    await d(
+      { text: `Similarity search to find fields: ${e.agentExecutionContext.assignedTask}` },
+      t
+    );
+    const a = u(t, "fieldSearch"), o = u(t, "layersAndFieldsRegistry"), n = u(t, "embeddingCache"), s = e.vectorSearchLayerResults?.map((c) => c.id) ?? [];
+    if (s.length === 0)
+      return await d({ text: "No candidate layers for field search" }, t), e;
+    const l = (await a.searchFields({
+      text: e.agentExecutionContext.assignedTask,
+      layerIds: s,
+      minScore: A,
+      topResults: _e,
+      embeddingCache: n
+    })).map(({ layerId: c, results: m }) => {
+      const g = o.get(c)?.fieldRegistry;
+      return {
+        layerId: c,
+        layerName: o.get(c)?.layerItem.name,
+        results: m.map((p) => {
+          const h = g?.get(p.name);
+          return {
+            name: p.name,
+            score: p.score,
+            type: h?.type,
+            alias: h?.alias,
+            description: h?.description,
+            statistics: h?.statistics,
+            domain: h?.domain
+          };
+        })
+      };
+    });
+    let i;
+    return l.length > 0 ? i = `Vector search completed. Matching layers and fields:
+${l.map(
+      (c) => `${c.layerName ?? c.layerId}:
+${c.results.map((m) => `  - ${m.name} (${m.score.toFixed(2)})`).join(`
+`)}`
+    ).join(`
+`)}` : i = `No vector search field results found for score over ${A}.`, await d({ text: i }, t), {
+      ...e,
+      vectorSearchFieldResults: l
+    };
+  } catch (a) {
+    throw await d(
+      { text: `Error during vector search fields: ${a instanceof Error ? a.message : String(a)}` },
+      t
+    ), a;
+  }
+}, De = (e, t) => L(["layerSearch", "layersAndFieldsRegistry"], "Navigation Agent")(e, t), ze = () => new T(G).addNode("requireNavigationServices", De).addNode("intentLLM", Fe).addNode("vectorSearchLayers", qe).addNode("vectorSearchFields", Ie).addNode("agent", ke).addNode("tools", Ae).addEdge(b, "requireNavigationServices").addEdge("requireNavigationServices", "intentLLM").addConditionalEdges(
+  "intentLLM",
+  (t) => t.intent === "goToLayer" || t.intent === "goToFeatures" ? "vectorSearchLayers" : "agent",
+  {
+    vectorSearchLayers: "vectorSearchLayers",
+    agent: "agent"
+  }
+).addConditionalEdges(
+  "vectorSearchLayers",
+  (t) => t.intent === "goToFeatures" ? "vectorSearchFields" : "agent",
+  {
+    vectorSearchFields: "vectorSearchFields",
+    agent: "agent"
+  }
+).addEdge("vectorSearchFields", "agent").addEdge("agent", "tools").addEdge("tools", x), Ge = String.raw`- **navigation** — Enables users to interact with the map by navigating to specific locations, layers, features, or extents.  
+  This includes zooming, panning, centering, or geocoding based on user input. The agent is designed to handle explicit map movement requests. NOTE: DO NOT call this agent if the user asks "show me...", that is meant to be handled by another agent. If the query is about where a certain address is, call this agent.
+
+  Supported actions:
+  - **Zooming**: Adjust the map's zoom level (e.g., "Zoom to level 10", "Zoom in").
+  - **Viewpoints**: Navigate to a specific center point with optional zoom or scale (e.g., "Center the map on San Francisco at zoom level 16").
+  - **Scales**: Set the map to a specific scale (e.g., "Set the map scale to 1:50,000").
+  - **Layers**: Zoom to the full extent of a specific layer (e.g., "Go to the water mains layer").  For the purposes of link charts, if the user requests to go to the extent of a link chart or the entities/nodes within it, that should be treated as a request to use the goToLayer tool on the link chart layer
+  - **Features**: Zoom to features in a layer that match a filter (e.g., "Zoom to all schools in the city").
+  - **Bookmarks**: Navigate to a predefined bookmark extent (e.g., "Go to the Downtown bookmark").
+  - **Extents**: Reset to the initial web map extent or zoom to the full world extent (e.g., "Reset the map", "Zoom to the full world extent").
+  - **Addresses**: Zoom to an address or place name (e.g., "Zoom to 1600 Pennsylvania Ave").
+
+  _Example: “Zoom to Texas”_  
+  _Example: “Go to the water mains layer”_
+  _Example: “Zoom to to the extent of my link chart”_ 
+  _Example: “Center the map on San Francisco at scale 50000”_  
+  _Example: “Zoom to the features in the schools layer where city = 'Austin'”_  
+  _Example: “Go to the Downtown bookmark”_  
+  _Example: “Where is Mount Rainier?”_`, Pe = {
+  id: "navigationGraph",
+  name: "Navigation Graph Agent",
+  description: Ge,
+  createGraph: ze,
+  workspace: G
+}, Ve = async (e, t) => (await d({ text: "Exiting Data Exploration agent" }, t), e), He = async (e, t) => {
+  await d({ text: "Requesting LLM for layer filter results" }, t);
+  const o = await S("data_explore_filter_prompt");
+  if (!t?.configurable)
+    throw new Error("config.configurable is required for layer filter tools");
+  const { userTimezone: n, userTimezoneOffset: s } = j(), r = {
+    layerFieldInfo: e.layerFieldInfo,
+    userTimezone: n,
+    userTimezoneOffset: s,
+    queryResponse: e.queryResponse,
+    assignedTask: e.agentExecutionContext.assignedTask,
+    userRequest: e.agentExecutionContext.userRequest,
+    priorSteps: e.agentExecutionContext.priorSteps
+  }, l = await v({
+    promptText: o,
+    modelTier: "default",
+    config: t,
+    messages: e.dataExplorationMessages,
+    inputVariables: r,
+    tools: P
+  }), i = [...e.dataExplorationMessages, l];
+  if (!((l.tool_calls?.length ?? 0) > 0))
+    return await d({ text: "LLM determined no filter changes needed" }, t), {
+      ...e,
+      dataExplorationMessages: i
+      // Don't overwrite outputMessage if query already set it
+    };
+  const m = i, g = l.content.toString();
+  return await w(l, t), { ...e, dataExplorationMessages: m, outputMessage: g };
+}, je = async (e, t) => {
+  await d({ text: "Requesting LLM for layer query results" }, t);
+  const o = await S("data_explore_query_prompt");
+  if (!t?.configurable)
+    throw new Error("config.configurable is required for layer query tools");
+  const { userTimezone: n, userTimezoneOffset: s } = j(), r = e.agentExecutionContext.sharedState, l = r.lastNavigatedFeatures?.value, i = r.lastResolvedLocation?.value;
+  let c = "none";
+  if (l != null)
+    try {
+      c = JSON.stringify(l);
+    } catch {
+      c = "none";
+    }
+  let m = "none";
+  if (i != null)
+    try {
+      m = JSON.stringify({
+        address: i.address,
+        location: i.location
+      });
+    } catch {
+      m = "none";
+    }
+  const g = {
+    layerFieldInfo: e.layerFieldInfo,
+    userTimezone: n,
+    userTimezoneOffset: s,
+    assignedTask: e.agentExecutionContext.assignedTask,
+    userRequest: e.agentExecutionContext.userRequest,
+    priorSteps: e.agentExecutionContext.priorSteps,
+    lastNavigatedFeatures: c,
+    lastResolvedLocation: m
+  }, p = await v({
+    promptText: o,
+    modelTier: "default",
+    config: t,
+    messages: e.dataExplorationMessages,
+    inputVariables: g,
+    tools: ie
+  }), h = (p.tool_calls?.length ?? 0) > 0, y = p.content.toString();
+  return await w(p, t), {
+    ...e,
+    dataExplorationMessages: [...e.dataExplorationMessages, p],
+    // Only emit output here when no tools are being called.
+    // For tool-calling flows, downstream summarizer nodes provide the final user-facing message.
+    ...h ? {} : { outputMessage: y },
+    status: "success",
+    summary: y && !h ? E(y) : "Query planning completed."
+  };
+}, Oe = async (e, t) => {
+  try {
+    await d({ text: "Requesting LLM for summary on query results" }, t);
+    const o = await S("summarize_query_response_prompt"), n = {
+      queryResponse: e.queryResponse,
+      assignedTask: e.agentExecutionContext.assignedTask,
+      userRequest: e.agentExecutionContext.userRequest,
+      priorSteps: e.agentExecutionContext.priorSteps
+    }, s = await z({
+      promptText: o,
+      modelTier: "fast",
+      config: t,
+      messages: e.dataExplorationMessages,
+      inputVariables: n
+    }), r = typeof s == "string" ? s : s.content, l = new ce(r);
+    await d({ text: `Received response from LLM: ${r}` }, t);
+    const i = r;
+    return {
+      ...e,
+      outputMessage: i,
+      status: "success",
+      summary: i ? E(i) : "Summary generated.",
+      dataExplorationMessages: [...e.dataExplorationMessages, l]
+    };
+  } catch (a) {
+    throw await d({ text: "Error during filter LLM request" }, t), new Error(`Error during filter LLM request: ${a instanceof Error ? a.message : String(a)}`);
+  }
+};
+async function We(e, t) {
+  if ((e.queryResponse ?? []).some((s) => {
+    const r = s.details;
+    return typeof r == "object" && r !== null && "error" in r;
+  }))
+    return await d({ text: "Skipping layer filter tool because query response contains an error." }, t), { ...e };
+  const n = await new M(P, { handleToolErrors: !1 }).invoke(
+    {
+      messages: e.dataExplorationMessages
+    },
+    t
+  );
+  return await d(
+    { text: `Finished executing layer filter tool: ${n.messages.map((s) => s.content).join(", ")}` },
+    t
+  ), { ...e };
+}
+const F = /\b(average|avg|mean|median|max(?:imum)?|min(?:imum)?|sum|total|count|std(?:dev|\s*deviation)|variance|null\s*count|missing\s*values?|range)\b/iu;
+function Ze(e, t) {
+  return F.test(e) || F.test(t);
+}
+const Qe = async (e, t) => {
+  try {
+    await d({ text: "Preparing field information for vector search results" }, t);
+    const a = u(t, "layersAndFieldsRegistry"), { mapView: o } = $(t, ["mapView"]), { assignedTask: n, userRequest: s } = e.agentExecutionContext, r = Ze(n, s), { layerFieldInfo: l, didFetchStatistics: i, fieldStatisticsFetchStatus: c } = await Ee(
+      e.vectorSearchFieldResults,
+      a,
+      o,
+      r
+    );
+    i ? await d({ text: "Statistics fetched" }, t) : await d({ text: "Statistics skipped" }, t);
+    for (const m of c)
+      await d(
+        {
+          text: `  - ${m.fieldName} - stats ${m.didFetchStatistics ? "fetched" : "skipped"}`
+        },
+        t
+      );
+    return await d({ text: "Field information prepared" }, t), { ...e, layerFieldInfo: l };
+  } catch (a) {
+    throw await d({ text: "Error during fetching statistics" }, t), new Error(`Error during fetching statistics: ${a instanceof Error ? a.message : String(a)}`);
+  }
+}, N = 0.7, Be = 10, Je = async (e, t) => {
+  try {
+    await d({ text: "Similarity search to find fields" }, t);
+    const a = u(t, "fieldSearch"), o = u(t, "layersAndFieldsRegistry"), n = u(t, "embeddingCache"), s = await a.searchFields({
+      text: e.agentExecutionContext.assignedTask,
+      layerIds: e.vectorSearchLayerIds,
+      minScore: N,
+      topResults: Be,
+      embeddingCache: n
+    }), r = s.map(({ layerId: i, results: c }) => {
+      const m = c.map((g) => `  - ${g.name} (${g.score.toFixed(2)})`).join(`
+`);
+      return `${o.get(i)?.layerItem.name ?? i}:
+${m}`;
+    }).join(`
+`);
+    let l;
+    return s.length > 0 ? l = `Vector search completed. Matching layers and fields with scores:
+${r}` : l = `No vector search results found for score over ${N}.`, await d({ text: l }, t), {
+      ...e,
+      vectorSearchFieldResults: s
+    };
+  } catch (a) {
+    throw await d(
+      { text: `Error during vector search: ${a instanceof Error ? a.message : String(a)}` },
+      t
+    ), new Error(`Vector search failed: ${a instanceof Error ? a.message : String(a)}`);
+  }
+}, Ue = 0.7, Ke = async (e, t) => {
+  try {
+    await d(
+      { text: `Similarity search to find layers: ${e.agentExecutionContext.assignedTask}` },
+      t
+    );
+    const a = u(t, "layerSearch"), o = u(t, "layersAndFieldsRegistry"), n = u(t, "embeddingCache"), s = await a.searchLayers({
+      text: e.agentExecutionContext.assignedTask,
+      minScore: Ue,
+      embeddingCache: n
+    }), r = s.map((c) => c.id), l = s.map(({ id: c, score: m }) => `${o.get(c)?.layerItem.name ?? c} (${m.toFixed(2)})`).join(`
+`);
+    let i;
+    return r.length > 0 ? i = `Vector search completed. Matching layers with scores:
+${l}` : i = "Vector search completed. No matching layers found.", await d({ text: i }, t), {
+      ...e,
+      vectorSearchLayerIds: r
+    };
+  } catch (a) {
+    throw await d(
+      { text: `Error during vector search: ${a instanceof Error ? a.message : String(a)}` },
+      t
+    ), new Error(`Vector search failed: ${a instanceof Error ? a.message : String(a)}`);
+  }
+}, Xe = (e, t) => L(["layerSearch", "fieldSearch", "layersAndFieldsRegistry"], "Data Exploration Agent")(
+  e,
+  t
+), Ye = () => new T(V).addNode("requireDataExplorationServices", Xe).addNode("vectorSearchLayers", Ke).addNode("vectorSearchFields", Je).addNode("fieldStatistics", Qe).addNode("queryAgent", je).addNode("queryTools", le).addNode("summarizeQueryResponseLLM", Oe).addNode("filterAgent", He).addNode("filterTools", We).addNode("earlyExit", Ve).addEdge(b, "requireDataExplorationServices").addEdge("requireDataExplorationServices", "vectorSearchLayers").addConditionalEdges(
+  "vectorSearchLayers",
+  (t) => t.vectorSearchLayerIds.length ? "vectorSearchFields" : "earlyExit"
+).addConditionalEdges(
+  "vectorSearchFields",
+  (t) => t.vectorSearchFieldResults.length ? "fieldStatistics" : "earlyExit"
+).addEdge("fieldStatistics", "queryAgent").addConditionalEdges("queryAgent", (t) => (t.dataExplorationMessages[t.dataExplorationMessages.length - 1]?.tool_calls?.length ?? 0) > 0 ? "queryTools" : "filterAgent").addConditionalEdges(
+  "queryTools",
+  (t) => t.queryResponse.length ? "summarizeQueryResponseLLM" : "filterAgent"
+).addEdge("summarizeQueryResponseLLM", "filterAgent").addConditionalEdges("filterAgent", (t) => (t.dataExplorationMessages[t.dataExplorationMessages.length - 1]?.tool_calls?.length ?? 0) > 0 ? "filterTools" : x).addEdge("filterTools", x).addEdge("earlyExit", x), et = String.raw`- **data exploration** — User is asking about the feature layer’s data (e.g. counts, summaries, statistics, field values), either for all features, a subset based on a condition, or for a subset based on the current view. And/Or user wants to include or exclude features based on field values, or visually style features differently (e.g., highlight or deemphasize them).
+  The Data Exploration Agent will automatically zoom to the affected features for action taken by this agent. In this case, no need to call navigation tool separately.  
+  _Example: “Only show stations where Brand is Shell”_  
+  _Example: “Make Shell stations stand out on the map”_  
+  _Example: “Gray out all stations that aren’t Shell”_
+  This also includes questions that ask which feature meets a given condition or where a particular feature in the data is located (e.g., “Where is the spring with the highest elevation?”). However, this agent does not handle addresses.
+  _Example: “How many features are there?”_  
+  _Example: “What’s the average population?”_  
+  _Example: “Which values are in the status field?”_
+
+  This agent does NOT handle help/metadata requests such as listing available layers, listing field names/columns/attributes for a layer, or capability guidance.`, tt = {
+  id: "dataExplorationGraph",
+  name: "Data Exploration Graph Agent",
+  description: et,
+  createGraph: Ye,
+  workspace: V
+}, O = [Te], at = (e) => {
+  if (!e || e.size === 0)
+    return "No layers available in this map.";
+  const t = Array.from(e.values()).map(({ layerItem: a, fieldRegistry: o }, n) => {
+    const s = Array.from(o.values()).map((l) => l.name).slice(0, 10).join(", "), r = o.size > 10 ? ` (and ${o.size - 10} more)` : "";
+    return `${n + 1}. "${a.title}". Description: ${a.description}
+   Fields: ${s}${r}`;
+  }).join(`
+
+`);
+  return `This map contains ${e.size} layer(s):
+
+${t}`;
+}, ot = (e) => {
+  const t = e?.list() ?? [];
+  return t.length ? t.map((a) => `- ${a.agent.name}: ${a.agent.description}`).join(`
+`) : "No agents currently available.";
+};
+async function st(e, t) {
+  const a = await S("help_prompt"), o = u(t, "layersAndFieldsRegistry"), n = u(t, "agentRegistry");
+  try {
+    const s = await v({
+      promptText: a,
+      modelTier: "default",
+      config: t,
+      tools: O,
+      inputVariables: {
+        layerSummary: at(o),
+        agents: ot(n),
+        assignedTask: e.agentExecutionContext.assignedTask,
+        userRequest: e.agentExecutionContext.userRequest,
+        priorSteps: e.agentExecutionContext.priorSteps
+      }
+    });
+    await w(s, t);
+    const r = (s.tool_calls?.length ?? 0) > 0, l = typeof s.text == "string" ? s.text.trim() : "";
+    return {
+      ...e,
+      helpInternalState: {
+        ...e.helpInternalState,
+        toolCallMessage: r ? s : void 0
+      },
+      outputMessage: r ? e.outputMessage : l,
+      summary: r ? "Prepared help tool call from assigned task." : "Provided map-related help based on the assigned task.",
+      status: r ? e.status : "success"
+    };
+  } catch (s) {
+    const r = s instanceof Error ? s.message : String(s);
+    return {
+      ...e,
+      outputMessage: `Error invoking help agent: ${r}`,
+      summary: "Help agent execution failed.",
+      status: "failed"
+    };
+  }
+}
+const rt = (e, t) => L(["agentRegistry"], "Help Agent")(e, t);
+async function nt(e, t) {
+  const a = new M(O, { handleToolErrors: !1 });
+  try {
+    const o = e.helpInternalState.toolCallMessage;
+    if (!o)
+      throw new Error("helpToolCalling: missing helpInternalState.toolCallMessage");
+    const s = (await a.invoke({ messages: [o] }, t)).messages.map((r) => r.text).join(`
+`);
+    return await d({ text: `Finished executing help tool: ${s}` }, t), {
+      ...e,
+      outputMessage: s,
+      status: "success",
+      summary: s ? E(s) : "Help executed.",
+      helpInternalState: {
+        ...e.helpInternalState,
+        toolCallMessage: void 0
+      }
+    };
+  } catch (o) {
+    const n = o instanceof Error ? o.message : String(o);
+    return await d({ text: `Help tool execution failed: ${n}` }, t), {
+      ...e,
+      outputMessage: `Help tool execution failed: ${n}`,
+      status: "failed",
+      summary: `Help tool execution failed: ${n}`,
+      helpInternalState: {
+        ...e.helpInternalState,
+        toolCallMessage: void 0
+      }
+    };
+  }
+}
+const it = () => new T(H).addNode("requireHelpServices", rt).addNode("agent", st).addNode("tools", nt).addEdge(b, "requireHelpServices").addEdge("requireHelpServices", "agent").addConditionalEdges("agent", (t) => t.helpInternalState.toolCallMessage ? "tools" : x).addEdge("tools", x), lt = String.raw`- **help** — Enables users to ask questions about the map, layers, fields, and it's capabilities.
+
+  _Example: “Tell me about this map”_  
+  _Example: “List all layers in this map”_  
+  _Example: “List fields in protected areas layer”_  
+  _Example: “What agents are available to me?”_  
+  _Example: “What can you do?”_  
+  _Example: “What can I ask”_
+  
+  If the user asks unrelated queries like "What are the vowels in English alphabet" or "How to cook", call this agent so it can politely refuse and redirect to map-related questions.
+  
+  IF the user asks map related queries, but those that are not performed by any of the agents, call this agent so we can respond that the requested action is not supported.
+  _Example: "Create a chart"_
+  _Example: "Create a table"_`, ct = {
+  id: "helpGraph",
+  name: "Help Graph Agent",
+  description: lt,
+  createGraph: it,
+  workspace: H
+}, Ut = z, Kt = D, Xt = v, Yt = d, ea = q, ta = Re, aa = ne, oa = Pe, sa = Se, ra = ve, na = tt, ia = we, la = ct, ca = be, da = Me, ma = () => se(), pa = () => re(), ga = async (e, t) => await Q(e, t), ua = async ({
   modelTier: e = "default",
-  temperature: t = 0,
-  config: s
-} = {}) => await x({ modelTier: e, temperature: t, config: s });
+  config: t
+} = {}) => await te({ modelTier: e, config: t });
 export {
-  ce as ArcgisKnowledgeAgent,
-  ne as DataExplorationAgent,
-  ie as HelpAgent,
-  re as LayerStylingAgent,
-  oe as NavigationAgent,
-  ue as Orchestrator,
-  se as cosineSimilarity,
-  le as createAgentRuntimeState,
-  de as createAgentRuntimeStateWithSharedState,
-  pe as createChatModel,
-  me as createWebmapEmbeddings,
-  ae as getEmbeddings,
-  Z as invokeStructuredPrompt,
-  Y as invokeTextPrompt,
-  ee as invokeToolPrompt,
-  te as sendTraceMessage,
-  ge as sendUXSuggestion
+  ca as ArcgisKnowledgeAgent,
+  ra as DataExplorationAgent,
+  na as DataExplorationGraphAgent,
+  ia as HelpAgent,
+  la as HelpGraphAgent,
+  sa as LayerStylingAgent,
+  aa as NavigationAgent,
+  oa as NavigationGraphAgent,
+  fa as Orchestrator,
+  ta as cosineSimilarity,
+  ma as createAgentRuntimeState,
+  pa as createAgentRuntimeStateWithSharedState,
+  ua as createChatModel,
+  da as createWebmapEmbeddings,
+  ea as getEmbeddings,
+  Kt as invokeStructuredPrompt,
+  Ut as invokeTextPrompt,
+  Xt as invokeToolPrompt,
+  Yt as sendTraceMessage,
+  ga as sendUXSuggestion
 };