@arcgis/ai-components 5.1.0-next.99 → 5.1.0

package/dist/chunks/navigationGraph.js

@@ -0,0 +1,271 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
+import { StateGraph as E, START as $, END as C } from "@langchain/langgraph/web";
+import { k as F, m as R, n as L, o as M, p as A, u as _, v as I, w as q, x as Z, g as T, y as k, t as j, f as u, r as P, N as w } from "./adapter.js";
+import "@arcgis/core/identity/IdentityManager.js";
+import "@arcgis/core/portal/Portal.js";
+import "@arcgis/toolkit/string";
+import { h as V, i as z } from "./generateLayerDescriptions.js";
+import "@langchain/core/messages";
+import "@langchain/core/callbacks/dispatch/web";
+import "@langchain/openai";
+import "@arcgis/core/config.js";
+import "@arcgis/core/core/reactiveUtils.js";
+import "@arcgis/core/layers/FeatureLayer.js";
+import "@arcgis/core/request.js";
+import { s as h } from "./index.js";
+import "@langchain/core/prompts";
+import { ToolNode as G } from "@langchain/langgraph/prebuilt";
+import x from "zod";
+const S = [
+  F,
+  R,
+  L,
+  M,
+  A,
+  _,
+  I,
+  q,
+  Z
+];
+async function O(e, t) {
+  const o = await T("navigation_tool_prompt"), { mapView: s } = k(t), i = s.map.bookmarks?.map((p) => p.name).filter(Boolean) ?? [], l = e.vectorSearchLayerResults?.length > 0 ? e.vectorSearchLayerResults.map(
+    (p, b) => `${b + 1}. layerId=${p.id} | title=${p.title ?? ""} | name=${p.name ?? ""} | score=${p.score.toFixed(2)}`
+  ).join(`
+`) : "", c = e.vectorSearchFieldResults?.length > 0 ? JSON.stringify(e.vectorSearchFieldResults, null, 2) : "", a = e.intent === "goToBookmark" && i.length ? `Available bookmarks:
+${i.map((p) => `- ${p}`).join(`
+`)}` : "", r = (e.intent === "goToLayer" || e.intent === "goToFeatures") && e.vectorSearchLayerResults?.length ? `Candidate layers:
+${l}` : "", d = e.intent === "goToFeatures" && e.vectorSearchFieldResults?.length ? `Candidate fields:
+${c}` : "", y = {
+    intent: e.intent,
+    bookmarksSection: a,
+    layersSection: r,
+    fieldsSection: d,
+    currentZoom: s.zoom,
+    assignedTask: e.agentExecutionContext.assignedTask,
+    userRequest: e.agentExecutionContext.userRequest,
+    priorSteps: e.agentExecutionContext.priorSteps
+  }, n = await V({
+    promptText: o,
+    modelTier: "fast",
+    config: t,
+    inputVariables: y,
+    tools: S
+  }), m = (n.tool_calls?.length ?? 0) > 0, v = typeof n.text == "string" ? n.text.trim() : "", N = v.length > 0;
+  return {
+    ...e,
+    navigationInternalState: {
+      ...e.navigationInternalState,
+      toolCallMessage: m ? n : void 0
+    },
+    // No tool call => surface fallback text now. Tool call => tool node will set output.
+    outputMessage: m ? e.outputMessage : v,
+    status: m ? e.status : N ? "success" : "failed"
+  };
+}
+const B = (e) => {
+  const t = typeof e == "string" ? e : String(e);
+  try {
+    const o = JSON.parse(t);
+    if (o && typeof o == "object" && typeof o.text == "string")
+      return o;
+  } catch {
+    console.warn("Failed to parse tool response as JSON:", t);
+  }
+  return { text: t };
+};
+async function D(e, t) {
+  const o = new G(S, { handleToolErrors: !1 });
+  try {
+    const s = e.navigationInternalState.toolCallMessage;
+    if (!s)
+      throw new Error("navigationToolCalling: missing navigationInternalState.toolCallMessage");
+    const { messages: g } = await o.invoke(
+      {
+        messages: [s]
+      },
+      t
+    );
+    let i = "", l;
+    for (const c of g) {
+      const a = B(c.content);
+      a.text && (i += `${a.text}
+`), a.sharedStatePatch && (l = {
+        ...l,
+        ...a.sharedStatePatch
+      });
+    }
+    return await h({ text: `Finished executing navigation tool: ${i}` }, t), {
+      ...e,
+      outputMessage: i,
+      sharedStatePatch: l,
+      status: "success",
+      summary: i ? j(i) : "Navigation executed.",
+      navigationInternalState: {
+        ...e.navigationInternalState,
+        toolCallMessage: void 0
+      }
+    };
+  } catch (s) {
+    const g = s instanceof Error ? s.message : String(s);
+    return await h({ text: `Navigation tool execution failed: ${g}` }, t), {
+      ...e,
+      outputMessage: `Navigation tool execution failed: ${g}`,
+      status: "failed",
+      summary: `Navigation tool execution failed: ${g}`,
+      navigationInternalState: {
+        ...e.navigationInternalState,
+        toolCallMessage: void 0
+      }
+    };
+  }
+}
+async function J(e, t) {
+  const o = await T("navigation_intent_prompt"), { mapView: s } = k(t), g = S.map((n) => ({
+    name: n.name,
+    description: n.description,
+    schema: n.schema
+  })), l = s.map.bookmarks?.map((n) => n.name).filter(Boolean) ?? [], c = l.length ? `Available bookmarks:
+${l.map((n) => `- ${n}`).join(`
+`)}` : "No bookmarks are available in this map.", a = {
+    tools: g.map(({ name: n, description: m, schema: v }) => `${n}: ${m}, ${JSON.stringify(v)}`).join(`
+`),
+    bookmarks: c,
+    assignedTask: e.agentExecutionContext.assignedTask,
+    userRequest: e.agentExecutionContext.userRequest,
+    priorSteps: e.agentExecutionContext.priorSteps
+  }, r = x.object({
+    intent: x.string()
+  }), d = await z({
+    promptText: o,
+    config: t,
+    inputVariables: a,
+    schema: r,
+    modelTier: "fast"
+  }), y = typeof d.intent == "string" ? d.intent.trim().replace(/^"|"$/gu, "") : "";
+  return { ...e, intent: y || "" };
+}
+const H = 0.7, U = async (e, t) => {
+  try {
+    await h(
+      { text: `Similarity search to find layers: ${e.agentExecutionContext.assignedTask}` },
+      t
+    );
+    const o = u(t, "layerSearch"), s = u(t, "layersAndFieldsRegistry"), g = u(t, "embeddingCache"), l = (await o.searchLayers({
+      text: e.agentExecutionContext.assignedTask,
+      minScore: H,
+      embeddingCache: g
+    })).map(({ id: a, score: r }) => {
+      const d = s.get(a)?.layerItem;
+      return {
+        id: a,
+        title: d?.title,
+        name: d?.name ?? void 0,
+        score: r
+      };
+    });
+    let c;
+    return l.length > 0 ? c = `Vector search completed. Matching layers:
+${l.map((a) => `- layerId=${a.id} | title=${a.title ?? ""} | name=${a.name ?? ""} | score=${a.score.toFixed(2)}`).join(`
+`)}` : c = "Vector search completed. No matching layers found.", await h({ text: c }, t), {
+      ...e,
+      vectorSearchLayerResults: l
+    };
+  } catch (o) {
+    throw await h(
+      { text: `Error during vector search layers: ${o instanceof Error ? o.message : String(o)}` },
+      t
+    ), o;
+  }
+}, f = 0.7, W = 10, K = async (e, t) => {
+  try {
+    await h(
+      { text: `Similarity search to find fields: ${e.agentExecutionContext.assignedTask}` },
+      t
+    );
+    const o = u(t, "fieldSearch"), s = u(t, "layersAndFieldsRegistry"), g = u(t, "embeddingCache"), i = e.vectorSearchLayerResults?.map((r) => r.id) ?? [];
+    if (i.length === 0)
+      return await h({ text: "No candidate layers for field search" }, t), e;
+    const c = (await o.searchFields({
+      text: e.agentExecutionContext.assignedTask,
+      layerIds: i,
+      minScore: f,
+      topResults: W,
+      embeddingCache: g
+    })).map(({ layerId: r, results: d }) => {
+      const y = s.get(r)?.fieldRegistry;
+      return {
+        layerId: r,
+        layerName: s.get(r)?.layerItem.name,
+        results: d.map((n) => {
+          const m = y?.get(n.name);
+          return {
+            name: n.name,
+            score: n.score,
+            type: m?.type,
+            alias: m?.alias,
+            description: m?.description,
+            statistics: m?.statistics
+          };
+        })
+      };
+    });
+    let a;
+    return c.length > 0 ? a = `Vector search completed. Matching layers and fields:
+${c.map(
+      (r) => `${r.layerName ?? r.layerId}:
+${r.results.map((d) => `  - ${d.name} (${d.score.toFixed(2)})`).join(`
+`)}`
+    ).join(`
+`)}` : a = `No vector search field results found for score over ${f}.`, await h({ text: a }, t), {
+      ...e,
+      vectorSearchFieldResults: c
+    };
+  } catch (o) {
+    throw await h(
+      { text: `Error during vector search fields: ${o instanceof Error ? o.message : String(o)}` },
+      t
+    ), o;
+  }
+}, Q = (e, t) => P(["layerSearch", "layersAndFieldsRegistry"], "Navigation Agent")(e, t), X = () => new E(w).addNode("requireNavigationServices", Q).addNode("intentLLM", J).addNode("vectorSearchLayers", U).addNode("vectorSearchFields", K).addNode("agent", O).addNode("tools", D).addEdge($, "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", C), Y = 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?”_`, ve = {
+  id: "navigation",
+  name: "Navigation Agent",
+  description: Y,
+  createGraph: X,
+  workspace: w
+};
+export {
+  ve as N
+};

package/dist/chunks/navigation_intent_prompt.js

@@ -0,0 +1,52 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
+const e = `## Navigation Agent - Tool Intent Classifier
+
+You are an assistant that classifies the assigned task intent for navigation agent.
+
+You are given the following tool options:
+{tools}
+
+Bookmarks: {bookmarks}
+
+Assigned task:
+{assignedTask}
+
+Latest user request:
+{userRequest}
+
+Prior steps:
+{priorSteps}
+
+Use the assigned task as the primary instruction for the current query. The question will **not** be restated again here.
+Use the latest user request as supporting context when needed.
+Use prior steps only when the assigned task clearly depends on earlier results.
+
+Return exactly one intent (tool name) based on the assigned task.
+If none apply, return an **empty string**.
+
+Choose only from provided tools.
+
+## Note:
+
+This is the order of preference in case of overlap:
+
+1. Bookmark (if exists)
+2. Feature (if exists)
+3. Geocode / Address
+
+For example, "Where is Yosemite National Park". This is an address, but:
+A map that contains a bookmark with Yosemite National Park should prefer the bookmark.
+If bookmark does not exist, a map that has the National Parks layer, for example, should prefer the feature.
+If both of these do not exist, geocode and go to that address.
+
+Additional mapping guidance:
+
+- "zoom/go to [layer]" with no filter → prefer \`goToLayer\`.
+- "zoom/go to [features] where/with ..." (has a condition/filter) → prefer \`goToFeatures\`.
+- Explicit numeric zoom/scale/viewpoint requests → prefer the matching zoom/scale/viewpoint tool.
+
+Return the name of the tool as a string.
+`;
+export {
+  e as default
+};

package/dist/chunks/navigation_tool_prompt.js

@@ -0,0 +1,39 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
+const e = `# Navigation Tool Instructions
+
+CRITICAL: You are FORBIDDEN from making multiple tool calls. You MUST make exactly ONE tool call.
+
+Assigned task:
+{assignedTask}
+
+Latest user request:
+{userRequest}
+
+Prior steps:
+{priorSteps}
+
+Use the assigned task as the primary instruction for the current query. The question will **not** be restated again here.
+Use the latest user request as supporting context when needed.
+Use prior steps only when the assigned task clearly depends on earlier results.
+
+Detected intent:
+{intent}
+
+{bookmarksSection}
+
+{layersSection}
+
+{fieldsSection}
+
+Current zoom level: {currentZoom}
+
+Rules:
+
+- Call exactly one navigation tool
+- Use ONLY provided layerIds and fields if present
+- Do NOT invent layerIds or field names
+- If required context is missing, fall back to a valid non-layer tool
+`;
+export {
+  e as default
+};