@arcgis/ai-orchestrator 5.1.0-next.84 → 5.1.0-next.86

package/dist/index.js

@@ -1,12 +1,12 @@
 import R from "@arcgis/core/identity/IdentityManager.js";
 import I from "@arcgis/core/portal/Portal.js";
-import { Annotation as b, isGraphInterrupt as ne, StateGraph as re, START as se, END as ie, MemorySaver as ae } from "@langchain/langgraph/web";
-import { HumanMessage as W, AIMessage as P, isAIMessage as oe, isToolMessage as ce } from "@langchain/core/messages";
-import { dispatchCustomEvent as q } from "@langchain/core/callbacks/dispatch/web";
-import p, { z as l } from "zod";
+import { Annotation as x, isGraphInterrupt as ne, StateGraph as re, START as se, END as ie, MemorySaver as ae } from "@langchain/langgraph/web";
+import { HumanMessage as W, AIMessage as k, isAIMessage as oe, isToolMessage as ce } from "@langchain/core/messages";
+import { dispatchCustomEvent as j } from "@langchain/core/callbacks/dispatch/web";
+import h, { z as l } from "zod";
 import { ChatPromptTemplate as N, SystemMessagePromptTemplate as de } from "@langchain/core/prompts";
-import { createAgent as le, summarizationMiddleware as me, modelCallLimitMiddleware as ge } from "langchain";
-import { ChatOpenAI as ue, OpenAIEmbeddings as pe } from "@langchain/openai";
+import { createAgent as le, summarizationMiddleware as ue, modelCallLimitMiddleware as me } from "langchain";
+import { ChatOpenAI as ge, OpenAIEmbeddings as pe } from "@langchain/openai";
 import * as H from "@arcgis/core/core/reactiveUtils.js";
 import O from "@arcgis/core/layers/FeatureLayer.js";
 import he from "@arcgis/core/request.js";
@@ -14,20 +14,20 @@ const V = {
   advanced: "gpt-5.2",
   default: "gpt-5-mini",
   fast: "gpt-5.4-nano"
-}, k = {
+}, T = {
   default: "text-embedding-ada-002"
 }, M = /* @__PURE__ */ new Map();
 let E = null;
 const fe = () => {
-  const e = I.getDefault().helperServices;
-  if (!e?.aiModels?.url)
+  const t = I.getDefault().helperServices;
+  if (!t?.aiModels?.url)
     throw new Error("AI Models Service URL is not defined in the portal's helper services.");
-  return e.aiModels.url;
-}, z = async (t) => {
-  const e = fe();
+  return t.aiModels.url;
+}, z = async (e) => {
+  const t = fe();
   M.size === 0 && (E || (E = (async () => {
     try {
-      const n = await fetch(`${e}/models`);
+      const n = await fetch(`${t}/models`);
       if (!n.ok)
         throw new Error("Failed to fetch AI service discovery data.");
       (await n.json()).models.forEach((a) => M.set(a.name, a));
@@ -35,88 +35,97 @@ const fe = () => {
       throw E = null, n;
     }
   })()), await E);
-  const r = M.get(t);
+  const r = M.get(e);
   if (!r)
-    throw new Error(`Model '${t}' is not available in the discovery service.`);
+    throw new Error(`Model '${e}' is not available in the discovery service.`);
   return r.endpoint;
-}, ye = async (t = "default") => await z(V[t]), G = async (t = "default") => await z(k[t]), we = async (t) => {
-  const e = await ve(), r = await G("default"), n = I.getDefault(), a = (await R.getCredential(`${n.url}/sharing`)).token, i = {
+}, ye = async (e = "default") => await z(V[e]), G = async (e = "default") => await z(T[e]), we = async (e) => {
+  const t = await ve(), r = await G("default"), n = I.getDefault(), a = (await R.getCredential(`${n.url}/sharing`)).token, i = {
     type: "generateEmbeddings",
-    webmapEmbeddings: t,
+    webmapEmbeddings: e,
     auth: { apiUrl: r, token: a }
   };
-  return e.postMessage(i), await new Promise((c, o) => {
-    const d = (g) => {
-      g.data === "completed" && (e.removeEventListener("message", d), c());
-    }, m = (g) => {
-      e.removeEventListener("message", d), o(g instanceof Error ? g : new Error("Embeddings worker error"));
+  return t.postMessage(i), await new Promise((c, o) => {
+    const d = (m) => {
+      m.data === "completed" && (t.removeEventListener("message", d), c());
+    }, u = (m) => {
+      t.removeEventListener("message", d), o(m instanceof Error ? m : new Error("Embeddings worker error"));
     };
-    e.addEventListener("message", d), e.addEventListener("error", m, { once: !0 });
-  }), e;
+    t.addEventListener("message", d), t.addEventListener("error", u, { once: !0 });
+  }), t;
 }, ve = async () => {
   {
-    const t = (await import("./embeddings.worker-GH7zdYqF.js")).default;
-    return new t();
+    const e = (await import("./embeddings.worker-GH7zdYqF.js")).default;
+    return new e();
   }
-}, F = (t, e) => e, be = (t, e) => ({
-  ...t,
-  ...e
-}), xe = b.Root({
-  agentExecutionContext: b({
+}, L = (e, t) => t, xe = (e, t) => ({
+  ...e,
+  ...t
+}), be = x.Root({
+  agentExecutionContext: x({
     default: () => ({
       userRequest: "",
       assignedTask: "",
       priorSteps: [],
       messages: []
     }),
-    reducer: be
+    reducer: xe
   }),
-  currentIntent: b({
+  currentIntent: x({
     default: () => "none",
-    reducer: F
+    reducer: L
   }),
-  requiresFollowUp: b({
+  requiresFollowUp: x({
     default: () => !0,
-    reducer: F
+    reducer: L
   }),
-  stepCount: b({
+  stepCount: x({
     default: () => 0,
-    reducer: (t, e) => e ?? t + 1
+    reducer: (e, t) => t ?? e + 1
   })
-}), h = async (t, e) => {
-  await q("trace_message", t, e);
-}, ut = async (t, e) => {
-  await q("graph_ux_suggestion", t, e);
-}, Ee = (t) => {
-  t.currentIntent = "none";
-}, Ie = async (t, e) => {
-  if (t.agentExecutionContext.userRequest) {
-    const n = new W(t.agentExecutionContext.userRequest.trim());
-    t.agentExecutionContext.messages = [...t.agentExecutionContext.messages, n], Ee(t);
+}), f = async (e, t) => {
+  await j("trace_message", e, t);
+}, gt = async (e, t) => {
+  await j("graph_ux_suggestion", e, t);
+}, Ee = (e) => {
+  e.currentIntent = "none";
+}, Ie = async (e, t) => {
+  if (e.agentExecutionContext.userRequest) {
+    const n = new W(e.agentExecutionContext.userRequest.trim());
+    e.agentExecutionContext.messages = [...e.agentExecutionContext.messages, n], Ee(e);
   }
-  const r = e?.configurable?.services.agentRegistry.list().map((n) => n.agent.id) ?? [];
-  return await h({ text: `Available agents: ${[...r].join(", ")}` }, e), await h({ text: "Analyzing user input" }, e), t;
-}, Se = async (t, e) => (await h({ text: "Exiting..." }, e), t), L = 4e3, $ = (t) => {
-  if (typeof t != "string")
+  const r = t?.configurable?.services.agentRegistry.list().map((n) => n.agent.id) ?? [];
+  return await f({ text: `Available agents: ${[...r].join(", ")}` }, t), await f({ text: "Analyzing user input" }, t), e;
+}, Se = async (e, t) => (await f({ text: "Exiting..." }, t), e), $ = 4e3, q = (e) => {
+  if (typeof e != "string")
     return;
-  const e = t.trim();
-  return e || void 0;
-}, Me = (t) => t === "failed" || t === "partial" || t === "success", Re = (t) => t === "failed" ? "Agent failed without a summary." : t === "partial" ? "Agent partially completed without a summary." : "Agent completed without a summary.", ke = (t, e) => {
-  const r = $(e?.outputMessage), n = $(e?.summary), s = e?.status;
-  if (!Me(s))
-    throw new Error(`Registered agent "${t}" returned an invalid or missing status.`);
-  return {
+  const t = e.trim();
+  return t || void 0;
+}, Me = (e) => {
+  switch (e) {
+    case "failed":
+      return "Agent failed without a summary.";
+    case "unknown":
+      return "Agent returned with unknown status.";
+    case "success":
+      return "Agent completed without a summary.";
+    default:
+      return "Agent completed without a summary.";
+  }
+}, Re = (e, t) => {
+  const r = q(t?.outputMessage), n = q(t?.summary), s = t?.status ?? "unknown";
+  return s === "unknown" && console.warn(`Registered agent "${e}" returned an invalid or missing status.`), {
     outputMessage: r,
-    summary: n ?? r ?? Re(s),
+    summary: n ?? r ?? Me(s),
     status: s
   };
-}, Te = async (t, e) => {
-  const r = e?.configurable, { agentRegistry: n } = r.services, s = n?.get(t.currentIntent);
+}, ke = async (e, t) => {
+  const r = t?.configurable, { agentRegistry: n } = r.services, s = n?.get(e.currentIntent);
   if (!s)
-    return console.warn(`No agent found for intent: ${t.currentIntent}`), t;
-  await h({ text: `Executing registered agent: ${s.agent.name}` }, e);
+    return console.warn(`No agent found for intent: ${e.currentIntent}`), e;
+  await f({ text: `Executing registered agent: ${s.agent.name}` }, t);
   const a = {
-    ...e ?? {},
+    ...t ?? {},
     configurable: {
       ...r ?? {},
       agentId: s.agent.id,
@@ -128,80 +137,81 @@ const fe = () => {
     const d = await s.agent.createGraph().compile().invoke(
       {
         agentExecutionContext: {
-          ...t.agentExecutionContext,
-          messages: [...t.agentExecutionContext.messages],
-          priorSteps: [...t.agentExecutionContext.priorSteps ?? []]
+          ...e.agentExecutionContext,
+          messages: [...e.agentExecutionContext.messages],
+          priorSteps: [...e.agentExecutionContext.priorSteps ?? []]
         }
       },
       a
     );
-    i = ke(s.agent.name, d), await h({ text: `Finished executing registered agent: ${s.agent.name}` }, e);
+    i = Re(s.agent.name, d), await f({ text: `Finished executing registered agent: ${s.agent.name}` }, t);
   } catch (d) {
     if (ne(d))
       throw d;
-    const m = d instanceof Error ? d.message : String(d);
-    console.error(`Agent "${s.agent.name}" failed:`, d), await h({ text: `Registered agent failed: ${s.agent.name}. ${m}` }, e), i = {
+    const u = d instanceof Error ? d.message : String(d);
+    console.error(`Agent "${s.agent.name}" failed:`, d), await f({ text: `Registered agent failed: ${s.agent.name}. ${u}` }, t), i = {
       status: "failed",
-      outputMessage: `Agent execution failed: ${m}`,
-      summary: `Agent execution failed: ${m}`
+      outputMessage: `Agent execution failed: ${u}`,
+      summary: `Agent execution failed: ${u}`
     };
   }
-  const c = i.outputMessage, o = [...t.agentExecutionContext.messages];
+  const c = i.outputMessage, o = [...e.agentExecutionContext.messages];
   if (c) {
-    const d = c.length > L ? `${c.slice(0, L - 14)}
+    const d = c.length > $ ? `${c.slice(0, $ - 14)}
 [truncated]` : c;
-    o.push(new P(d));
+    o.push(new k(d));
   }
   return {
-    ...t,
-    stepCount: t.stepCount + 1,
+    ...e,
+    stepCount: e.stepCount + 1,
+    requiresFollowUp: i.status === "failed" ? !0 : e.requiresFollowUp,
     agentExecutionContext: {
-      ...t.agentExecutionContext,
+      ...e.agentExecutionContext,
       messages: o,
       priorSteps: [
-        ...t.agentExecutionContext.priorSteps ?? [],
+        ...e.agentExecutionContext.priorSteps ?? [],
         {
           agentId: s.agent.id,
-          assignedTask: t.agentExecutionContext.assignedTask,
-          summary: i.summary,
+          assignedTask: e.agentExecutionContext.assignedTask,
+          summary: i?.summary || "No summary provided.",
           status: i.status
         }
       ]
     }
   };
-}, Ae = (t, e, r) => {
-  const n = t[e];
+}, Te = (e, t, r) => {
+  const n = e[t];
   return n ? typeof n == "function" ? n() : Promise.resolve(n) : new Promise((s, a) => {
-    (typeof queueMicrotask == "function" ? queueMicrotask : setTimeout)(a.bind(null, /* @__PURE__ */ new Error("Unknown variable dynamic import: " + e + (e.split("/").length !== r ? ". Note that variables only represent file names one level deep." : ""))));
+    (typeof queueMicrotask == "function" ? queueMicrotask : setTimeout)(a.bind(null, /* @__PURE__ */ new Error("Unknown variable dynamic import: " + t + (t.split("/").length !== r ? ". Note that variables only represent file names one level deep." : ""))));
   });
-}, T = async (t) => (await Ae(/* @__PURE__ */ Object.assign({ "./field_descriptions_prompt.md": () => import("./field_descriptions_prompt-haMV_aoG.js"), "./intent_prompt.md": () => import("./intent_prompt-DULnCkLt.js"), "./layer_descriptions_prompt.md": () => import("./layer_descriptions_prompt-NAaKWdJi.js") }), `./${t}.md`, 2)).default, Ce = async (t) => {
-  const { agent: e, messages: r, config: n } = t;
-  return { structuredResponse: (await e.invoke(
+}, C = async (e) => (await Te(/* @__PURE__ */ Object.assign({ "./field_descriptions_prompt.md": () => import("./field_descriptions_prompt-haMV_aoG.js"), "./intent_prompt.md": () => import("./intent_prompt-BSRo2YLj.js"), "./layer_descriptions_prompt.md": () => import("./layer_descriptions_prompt-NAaKWdJi.js") }), `./${e}.md`, 2)).default, Ce = async (e) => {
+  const { agent: t, messages: r, config: n } = e;
+  return { structuredResponse: (await t.invoke(
     {
       messages: r
     },
     n
   )).structuredResponse };
-}, K = (t) => async (e, r) => {
+}, K = (e) => async (t, r) => {
   const n = new Headers(r?.headers);
-  return n.delete("Authorization"), n.delete("api-key"), t && t.length > 0 && (n.set("X-Esri-Authorization", `Bearer ${t}`), n.set("X-Esri-Request-Source", "MapsSDK")), await fetch(e, {
+  return n.delete("Authorization"), n.delete("api-key"), e && e.length > 0 && (n.set("X-Esri-Authorization", `Bearer ${e}`), n.set("X-Esri-Request-Source", "MapsSDK")), await fetch(t, {
     ...r,
     headers: n
   });
-}, x = async (t = "default", e = 0) => {
-  const r = I.getDefault(), n = await R.getCredential(`${r.url}/sharing`), s = V[t], a = await ye(t);
-  return new ue({
+}, b = async (e = "default", t = 0) => {
+  const r = I.getDefault(), n = await R.getCredential(`${r.url}/sharing`), s = V[e], a = await ye(e);
+  return new ge({
     modelName: s,
     apiKey: "dummy-key",
     // 5-mini does not support temperature parameter
-    ...t !== "default" && { temperature: e },
+    ...e !== "default" && { temperature: t },
     configuration: {
       baseURL: a,
       fetch: K(n.token)
     }
   });
-}, De = async (t = "default") => {
-  const e = I.getDefault(), r = await R.getCredential(`${e.url}/sharing`), n = k[t], s = await G(t);
+}, Ae = async (e = "default") => {
+  const t = I.getDefault(), r = await R.getCredential(`${t.url}/sharing`), n = T[e], s = await G(e);
   return new pe({
     modelName: n,
     apiKey: "dummy-key",
@@ -218,116 +228,138 @@ const fe = () => {
   description: l.string().min(1)
 });
 l.array(Fe);
-const Le = (t) => {
-  const e = t.map((n) => n.id), r = l.enum(e);
+const U = (e) => JSON.stringify(e, null, 2), De = (e) => {
+  const t = e.map((n) => n.id), r = l.enum(t);
   return l.object({
     intent: r.nullable(),
     assignedTask: l.string().nullable(),
     requiresFollowUp: l.boolean()
   });
-}, $e = async (t, e) => {
+}, Le = async (e, t) => {
   try {
-    await h({ text: "Asking LLM to route to an agent" }, e);
-    const s = (e?.configurable?.services.agentRegistry?.list() ?? []).map(({ agent: v }) => ({
+    await f({ text: "Asking LLM to route to an agent" }, t);
+    const s = (t?.configurable?.services.agentRegistry?.list() ?? []).map(({ agent: v }) => ({
       id: v.id,
       name: v.name,
       description: v.description
     }));
     if (!s.length)
-      return await h({ text: "No agents registered; skipping intent detection" }, e), { ...t, currentIntent: "none" };
-    const a = await T("intent_prompt"), i = s.map((v) => JSON.stringify(v)).join(`
-`), c = Le(s), o = {
+      return await f({ text: "No agents registered; skipping intent detection" }, t), { ...e, currentIntent: "none" };
+    const a = await C("intent_prompt"), i = U(s), c = De(s), o = {
       registeredAgents: i,
-      priorSteps: t.agentExecutionContext.priorSteps,
-      userRequest: t.agentExecutionContext.userRequest
-    }, m = await N.fromTemplate(a).format(o), g = le({
-      model: await x("default"),
+      priorSteps: U(e.agentExecutionContext.priorSteps),
+      userRequest: e.agentExecutionContext.userRequest
+    }, u = await N.fromTemplate(a).format(o), m = le({
+      model: await b("fast"),
       tools: [],
-      systemPrompt: m,
+      systemPrompt: u,
       checkpointer: !0,
       responseFormat: c,
       middleware: [
         // Preserve recent conversation context while summarizing older messages
         // to control token usage without losing important intent signals.
         // The trigger and keep parameters can be tuned based on token limits and behavior.
-        me({
-          model: await x("fast"),
+        ue({
+          model: await b("fast"),
           trigger: { tokens: 4e3 },
           keep: { messages: 6 }
         }),
         // Enforce no loop/retry.
         // 1 usual LLM call and 1 optional summarization call.
-        ge({ runLimit: 2 })
+        me({ runLimit: 2 })
       ]
     }), { structuredResponse: y } = await Ce({
-      agent: g,
-      messages: t.agentExecutionContext.messages,
-      config: e
-    }), f = c.parse(
+      agent: m,
+      messages: e.agentExecutionContext.messages,
+      config: t
+    }), p = c.parse(
       y ?? { intent: null, assignedTask: null, requiresFollowUp: !1 }
-    ), u = f.intent ?? "none", S = {
-      ...t,
-      currentIntent: u,
-      requiresFollowUp: f.requiresFollowUp,
+    ), g = p.intent ?? "none", S = {
+      ...e,
+      currentIntent: g,
+      requiresFollowUp: p.requiresFollowUp,
       agentExecutionContext: {
-        ...t.agentExecutionContext,
-        assignedTask: f.assignedTask ?? ""
+        ...e.agentExecutionContext,
+        assignedTask: p.assignedTask ?? ""
       }
     };
-    return await h({ text: `Intent came back as: ${u}` }, e), await h(
-      { text: `Agent picked: ${u}
-Task Assigned: ${f.assignedTask ?? ""}` },
-      e
+    if (g === "none") {
+      const v = "I could not find a matching agent for that request. Please rephrase your question with more detail.";
+      return await f({ text: "LLM did not identify a clear intent." }, t), {
+        ...e,
+        currentIntent: g,
+        requiresFollowUp: !1,
+        agentExecutionContext: {
+          ...e.agentExecutionContext,
+          assignedTask: "",
+          messages: [...e.agentExecutionContext.messages, new k(v)],
+          priorSteps: [
+            ...e.agentExecutionContext.priorSteps ?? [],
+            {
+              agentId: "no-intent-router",
+              assignedTask: e.agentExecutionContext.userRequest,
+              summary: "No matching agent found; asked user to rephrase.",
+              status: "success"
+            }
+          ]
+        }
+      };
+    }
+    return await f(
+      {
+        text: `Agent picked: ${g}
+Task Assigned: ${p.assignedTask ?? ""}
+Requires Follow-Up: ${p.requiresFollowUp}`
+      },
+      t
     ), S;
   } catch (r) {
-    throw await h({ text: "Error during intent detection" }, e), new Error(`Error during intent detection: ${r instanceof Error ? r.message : String(r)}`);
+    throw await f({ text: "Error during intent detection" }, t), new Error(`Error during intent detection: ${r instanceof Error ? r.message : String(r)}`);
   }
-}, _ = 3, _e = () => new re(xe).addNode("ingestInput", Ie).addNode("intentLLM", $e).addNode("executeRegisteredAgent", Te).addNode("exit", Se).addEdge(se, "ingestInput").addEdge("ingestInput", "intentLLM").addConditionalEdges("intentLLM", (e) => e.currentIntent === "none" ? "exit" : "executeRegisteredAgent").addConditionalEdges("executeRegisteredAgent", (e) => (console.log("[Dispatcher][executeRegisteredAgent]", {
-  intent: e.currentIntent,
-  followUp: e.requiresFollowUp,
-  step: e.stepCount,
-  maxSteps: _
-}), !e.requiresFollowUp || e.stepCount >= _ ? "exit" : "intentLLM")).addEdge("exit", ie);
-class je {
+}, $e = 3, qe = () => new re(be).addNode("ingestInput", Ie).addNode("intentLLM", Le).addNode("executeRegisteredAgent", ke).addNode("exit", Se).addEdge(se, "ingestInput").addEdge("ingestInput", "intentLLM").addConditionalEdges("intentLLM", (t) => t.currentIntent === "none" ? "exit" : "executeRegisteredAgent").addConditionalEdges(
+  "executeRegisteredAgent",
+  (t) => t.stepCount >= $e || !t.requiresFollowUp ? "exit" : "intentLLM"
+).addEdge("exit", ie);
+class Ue {
   constructor() {
     this.agentRegistry = /* @__PURE__ */ new Map();
   }
-  register(e) {
-    const { agent: r } = e;
+  register(t) {
+    const { agent: r } = t;
     if (this.agentRegistry.has(r.id))
       throw new Error(`Duplicate agent id: ${r.id}`);
-    this.agentRegistry.set(r.id, e);
+    this.agentRegistry.set(r.id, t);
   }
-  get(e) {
-    return this.agentRegistry.get(e);
+  get(t) {
+    return this.agentRegistry.get(t);
   }
   list() {
     return [...this.agentRegistry.values()];
   }
 }
-class Ue {
+class _e {
   /**
    * Create a new InterruptHandler tied to a specific compiled graph and config.
    */
-  constructor(e, r) {
-    this.graph = e, this.config = { ...r };
+  constructor(t, r) {
+    this.graph = t, this.config = { ...r };
   }
   /**
    * Returns a promise that resolves when the user provides a HITL response.
    */
   async waitForUser() {
-    return await new Promise((e, r) => {
-      this.resolveWait = e, this.rejectWait = r;
+    return await new Promise((t, r) => {
+      this.resolveWait = t, this.rejectWait = r;
     });
   }
   /**
    * Resume graph execution after the UI responds to an interrupt.
    */
-  handle(e, r) {
+  handle(t, r) {
     try {
       const n = {
-        agentId: e.agentId,
-        id: e.id,
+        agentId: t.agentId,
+        id: t.id,
         payload: r
       }, s = this.graph.streamEvents(null, {
         ...this.config,
@@ -352,32 +384,32 @@ class Ue {
     this.rejectWait && (this.rejectWait(new Error("Request cancelled by user.")), this.resolveWait = void 0, this.rejectWait = void 0);
   }
 }
-const We = (t) => {
-  let e = -1;
-  for (let r = t.length - 1; r >= 0; r--)
-    if (t[r] instanceof W) {
-      e = r;
+const Pe = (e) => {
+  let t = -1;
+  for (let r = e.length - 1; r >= 0; r--)
+    if (e[r] instanceof W) {
+      t = r;
       break;
     }
-  return e === -1 ? "" : t.slice(e + 1).filter((r) => r instanceof P).map((r) => r.content).join(`
+  return t === -1 ? "" : e.slice(t + 1).filter((r) => r instanceof k).map((r) => r.content).join(`
 `);
-}, B = async (t) => {
+}, B = async (e) => {
   try {
-    return await (await De()).embedDocuments(t);
-  } catch (e) {
-    throw console.error("Failed to generate embeddings:", e), e;
+    return await (await Ae()).embedDocuments(e);
+  } catch (t) {
+    throw console.error("Failed to generate embeddings:", t), t;
   }
-}, J = async (t, e) => {
-  const r = e.get(t);
+}, J = async (e, t) => {
+  const r = t.get(e);
   if (r)
     return r;
-  const n = await B([t]);
-  return e.set(t, n[0]), n[0];
+  const n = await B([e]);
+  return t.set(e, n[0]), n[0];
 };
-async function Pe(t, e, r, n) {
+async function We(e, t, r, n) {
   const s = `req-${Date.now()}`, i = {
     type: "layerSearch",
-    precomputedEmbedding: n ? await J(t, n) : void 0,
+    precomputedEmbedding: n ? await J(e, n) : void 0,
     requestId: s,
     minScore: r
   };
@@ -385,58 +417,58 @@ async function Pe(t, e, r, n) {
     const o = (d) => {
       d.data.requestId === s && c(d.data.results);
     };
-    e.addEventListener("message", o, { once: !0 }), e.postMessage(i);
+    t.addEventListener("message", o, { once: !0 }), t.postMessage(i);
   });
 }
-function qe(t) {
-  const { worker: e } = t;
+function je(e) {
+  const { worker: t } = e;
   return {
     async searchLayers({
       text: r,
       minScore: n,
       embeddingCache: s
     }) {
-      return await Pe(r, e, n, s);
+      return await We(r, t, n, s);
     }
   };
 }
 const Ne = async ({
-  combinedQuery: t,
-  layerIds: e,
+  combinedQuery: e,
+  layerIds: t,
   embeddingsWorker: r,
   minScore: n,
   topResults: s,
   embeddingCache: a
 }) => {
-  const i = `req-${Date.now()}`, c = a ? await J(t, a) : void 0, o = {
+  const i = `req-${Date.now()}`, c = a ? await J(e, a) : void 0, o = {
     type: "fieldSearch",
-    layerIdForFieldsSearch: e,
+    layerIdForFieldsSearch: t,
     precomputedEmbedding: c,
     requestId: i,
     minScore: n,
     topResults: s
   };
   return await new Promise((d) => {
-    const m = (g) => {
-      if (g.data.requestId !== i)
+    const u = (m) => {
+      if (m.data.requestId !== i)
         return;
-      const y = g.data.results.map(({ layerId: f, results: u }) => ({
-        layerId: f,
-        results: u
+      const y = m.data.results.map(({ layerId: p, results: g }) => ({
+        layerId: p,
+        results: g
       }));
       d(y);
     };
-    r.addEventListener("message", m, { once: !0 }), r.postMessage(o);
+    r.addEventListener("message", u, { once: !0 }), r.postMessage(o);
   });
 };
-function He(t) {
-  const { worker: e } = t;
+function He(e) {
+  const { worker: t } = e;
   return {
     async searchFields({ text: r, layerIds: n, minScore: s, topResults: a, embeddingCache: i }) {
       return await Ne({
         combinedQuery: r,
         layerIds: n,
-        embeddingsWorker: e,
+        embeddingsWorker: t,
         minScore: s,
         topResults: a,
         embeddingCache: i
@@ -444,9 +476,9 @@ function He(t) {
     }
   };
 }
-const X = "0.1", w = 1536, Q = "openai", Y = k.default, A = `Name: {name}
+const X = "0.1", w = 1536, Q = "openai", Y = T.default, A = `Name: {name}
 Title: {title}
-Description: {description}`, C = `Name: {name}
+Description: {description}`, F = `Name: {name}
 Alias: {alias}
 Description: {description}`, Z = l.object({
   schemaVersion: l.literal(X),
@@ -457,7 +489,7 @@ Description: {description}`, Z = l.object({
     dimensions: l.literal(w),
     templates: l.object({
       layer: l.string().default(A),
-      field: l.string().default(C)
+      field: l.string().default(F)
     })
   }),
   layers: l.array(
@@ -481,18 +513,18 @@ Description: {description}`, Z = l.object({
       )
     })
   ).default([])
-}), Oe = (t) => {
-  const e = Z.safeParse(t);
-  if (!e.success)
+}), Oe = (e) => {
+  const t = Z.safeParse(e);
+  if (!t.success)
     throw new Error("Embeddings response validation failed. Regenerate embeddings.");
-  return e.data;
-}, Ve = (t, e) => {
+  return t.data;
+}, Ve = (e, t) => {
   const r = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map();
-  if (e.allLayers.forEach((s) => {
+  if (t.allLayers.forEach((s) => {
     s instanceof O && n.set(s.id, s);
-  }), t.length !== n.size)
+  }), e.length !== n.size)
     throw new Error("Layer count mismatch during registry restoration. Regenerate embeddings.");
-  for (const s of t) {
+  for (const s of e) {
     const a = n.get(s.id);
     if (!a)
       throw new Error(
@@ -528,19 +560,19 @@ Description: {description}`, Z = l.object({
     });
   }
   return r;
-}, ze = async (t) => {
+}, ze = async (e) => {
   try {
-    return (await he(t, {
+    return (await he(e, {
       responseType: "json"
     })).data;
-  } catch (e) {
-    throw new Error(`Failed to fetch data from ${t}: ${String(e)}`);
+  } catch (t) {
+    throw new Error(`Failed to fetch data from ${e}: ${String(t)}`);
   }
-}, Ge = async (t) => {
-  const e = t.map;
-  if (!e?.portalItem)
+}, Ge = async (e) => {
+  const t = e.map;
+  if (!t?.portalItem)
     throw new Error("WebMap portal item is missing.");
-  const { resources: r } = await e.portalItem.fetchResources(), n = r.find((i) => i.resource.path === "embeddings-v01.json");
+  const { resources: r } = await t.portalItem.fetchResources(), n = r.find((i) => i.resource.path === "embeddings-v01.json");
   if (!n?.resource.url)
     throw new Error("Embeddings resource 'embeddings-v01.json' not found in the webmap portal item.");
   const s = await ze(n.resource.url);
@@ -548,25 +580,25 @@ Description: {description}`, Z = l.object({
 };
 class ee {
   constructor() {
-    this.orchestratorReady = !1, this.chatHistory = [], this.priorSteps = [], this.threadId = "", this.agentRegistry = new je(), this.streamEpoch = 0;
+    this.orchestratorReady = !1, this.chatHistory = [], this.priorSteps = [], this.threadId = "", this.agentRegistry = new Ue(), this.streamEpoch = 0;
   }
   /**
    * Creates and returns an AI-ready Orchestrator instance.
    * @param deps Core dependencies (layer/field registry plus optional map views).
    * @returns Ready Orchestrator.
    */
-  static async init(e) {
+  static async init(t) {
     const r = new ee();
     try {
-      if (e.view?.map) {
-        await H.whenOnce(() => e.view.ready);
-        const n = await Ge(e.view), s = Ve(
+      if (t.view?.map) {
+        await H.whenOnce(() => t.view.ready);
+        const n = await Ge(t.view), s = Ve(
           n.layers,
-          e.view.map
+          t.view.map
         );
         r.layersAndFieldsRegistry = s, r.embeddingsWorker = await we(n);
       }
-      return e.agents?.forEach((n) => {
+      return t.agents?.forEach((n) => {
         r.agentRegistry.register(n);
       }), r.orchestratorReady = !0, r;
     } catch (n) {
@@ -581,15 +613,15 @@ class ee {
    *  - `completed`: final result with chat history + layer styling
    *  - `cancelled`: user aborted the run
    */
-  async *ask(e) {
+  async *ask(t) {
     if (!this.orchestratorReady)
       throw new Error("Orchestrator is not ready yet.");
     if (!this.agentRegistry.list().length)
       throw new Error("Orchestrator has no registered agents.");
-    if (++this.streamEpoch, !e.trim())
+    if (++this.streamEpoch, !t.trim())
       return;
-    this.threadId = String(Date.now()), this.graph || (this.graph = _e().compile({ checkpointer: new ae() }));
-    const r = this.embeddingsWorker ? qe({ worker: this.embeddingsWorker }) : void 0, n = this.embeddingsWorker ? He({ worker: this.embeddingsWorker }) : void 0, s = /* @__PURE__ */ new Map(), i = {
+    this.threadId = String(Date.now()), this.graph || (this.graph = qe().compile({ checkpointer: new ae() }));
+    const r = this.embeddingsWorker ? je({ worker: this.embeddingsWorker }) : void 0, n = this.embeddingsWorker ? He({ worker: this.embeddingsWorker }) : void 0, s = /* @__PURE__ */ new Map(), i = {
       version: "v2",
       streamMode: "custom",
       configurable: {
@@ -606,24 +638,24 @@ class ee {
       },
       subgraphs: !0
     }, c = this.graph?.streamEvents(
-      { agentExecutionContext: { userRequest: e, messages: this.chatHistory, priorSteps: this.priorSteps } },
+      { agentExecutionContext: { userRequest: t, messages: this.chatHistory, priorSteps: this.priorSteps } },
       i
     ), o = ++this.streamEpoch;
     for (yield* this.pipeStream(c, o); ; ) {
-      const f = (await this.graph.getState(i, { subgraphs: !0 })).tasks.find((u) => u.interrupts.length > 0)?.interrupts[0]?.value;
-      if (!f)
+      const p = (await this.graph.getState(i, { subgraphs: !0 })).tasks.find((g) => g.interrupts.length > 0)?.interrupts[0]?.value;
+      if (!p)
         break;
-      this.currentInterrupt = f, this.interruptHandler = new Ue(this.graph, i), yield { runId: this.threadId, timestamp: Date.now(), type: "interrupt", interrupt: f };
+      this.currentInterrupt = p, this.interruptHandler = new _e(this.graph, i), yield { runId: this.threadId, timestamp: Date.now(), type: "interrupt", interrupt: p };
       try {
-        const u = await this.interruptHandler.waitForUser(), S = ++this.streamEpoch;
-        yield* this.pipeStream(u, S);
-      } catch (u) {
-        if (u) {
+        const g = await this.interruptHandler.waitForUser(), S = ++this.streamEpoch;
+        yield* this.pipeStream(g, S);
+      } catch (g) {
+        if (g) {
           yield {
             runId: this.threadId,
             timestamp: Date.now(),
             type: "error",
-            error: { message: u?.message }
+            error: { message: g?.message }
           };
           return;
         }
@@ -631,12 +663,12 @@ class ee {
         return;
       }
     }
-    const m = (await this.graph.getState(i, { subgraphs: !0 })).values;
-    this.chatHistory = m.agentExecutionContext.messages.length ? m.agentExecutionContext.messages : this.chatHistory, this.priorSteps = m.agentExecutionContext.priorSteps?.slice(-5) ?? [], yield {
+    const u = (await this.graph.getState(i, { subgraphs: !0 })).values;
+    this.chatHistory = u.agentExecutionContext.messages.length ? u.agentExecutionContext.messages : this.chatHistory, this.priorSteps = u.agentExecutionContext.priorSteps?.slice(-5) ?? [], yield {
       runId: this.threadId,
       timestamp: Date.now(),
       type: "completed",
-      result: { content: We(m.agentExecutionContext.messages) }
+      result: { content: Pe(u.agentExecutionContext.messages) }
     };
   }
   /**
@@ -649,10 +681,10 @@ class ee {
    * Generic resume for any HITL interrupt.
    * The payload is whatever the UI collected (e.g. "yes", "no", layerId, etc).
    */
-  resumeInterrupt(e) {
+  resumeInterrupt(t) {
     if (!this.currentInterrupt || !this.interruptHandler)
       throw new Error("No pending interrupt to resume.");
-    this.interruptHandler.handle(this.currentInterrupt, e);
+    this.interruptHandler.handle(this.currentInterrupt, t);
   }
   /**
    * Optional: allow UI to cancel the current HITL.
@@ -660,8 +692,8 @@ class ee {
   cancelInterrupt() {
     this.interruptHandler && this.interruptHandler.cancel();
   }
-  async *pipeStream(e, r) {
-    for await (const n of e) {
+  async *pipeStream(t, r) {
+    for await (const n of t) {
       if (r !== this.streamEpoch) {
         console.log("Stale stream detected, aborting.");
         break;
@@ -682,31 +714,31 @@ class ee {
     this.embeddingsWorker && (this.embeddingsWorker.terminate(), this.embeddingsWorker = void 0), this.orchestratorReady = !1;
   }
 }
-const Ke = (t) => {
-  const e = /* @__PURE__ */ new Set();
-  for (const n of t)
+const Ke = (e) => {
+  const t = /* @__PURE__ */ new Set();
+  for (const n of e)
     if (oe(n)) {
       const s = n;
       s.tool_calls && s.tool_calls.length > 0 && s.tool_calls.forEach((a) => {
-        a.id && e.add(a.id);
+        a.id && t.add(a.id);
       });
     }
-  return t.filter((n) => {
+  return e.filter((n) => {
     if (ce(n)) {
       const s = n;
-      return e.has(s.tool_call_id);
+      return t.has(s.tool_call_id);
     }
     return !0;
   });
-}, D = (t, e) => {
-  const r = de.fromTemplate(t);
-  return N.fromMessages([r, ...e]);
-}, Be = async (t) => {
-  const { promptText: e, modelTier: r, temperature: n, messages: s } = t, a = D(e, s ?? []), i = await x(r, n);
+}, D = (e, t) => {
+  const r = de.fromTemplate(e);
+  return N.fromMessages([r, ...t]);
+}, Be = async (e) => {
+  const { promptText: t, modelTier: r, temperature: n, messages: s } = e, a = D(t, s ?? []), i = await b(r, n);
   return a.pipe(i);
-}, pt = async (t) => {
-  const { promptText: e, modelTier: r = "default", temperature: n = 0, messages: s, inputVariables: a } = t, c = await (await Be({
-    promptText: e,
+}, pt = async (e) => {
+  const { promptText: t, modelTier: r = "default", temperature: n = 0, messages: s, inputVariables: a } = e, c = await (await Be({
+    promptText: t,
     modelTier: r,
     temperature: n,
     messages: s
@@ -715,75 +747,75 @@ const Ke = (t) => {
     return c;
   const o = c.content;
   return typeof o == "string" ? o : JSON.stringify(o);
-}, te = async (t) => {
-  const { promptText: e, modelTier: r = "default", temperature: n = 0, messages: s, inputVariables: a, schema: i } = t, c = D(e, s ?? []), d = (await x(r, n)).withStructuredOutput(i);
+}, te = async (e) => {
+  const { promptText: t, modelTier: r = "default", temperature: n = 0, messages: s, inputVariables: a, schema: i } = e, c = D(t, s ?? []), d = (await b(r, n)).withStructuredOutput(i);
   return await c.pipe(d).invoke(a ?? {});
-}, ht = async (t) => {
-  const { promptText: e, modelTier: r = "default", temperature: n = 0, messages: s, inputVariables: a, tools: i } = t, c = i.length > 0 ? Ke(s ?? []) : s ?? [], o = D(e, c), d = await x(r, n);
+}, ht = async (e) => {
+  const { promptText: t, modelTier: r = "default", temperature: n = 0, messages: s, inputVariables: a, tools: i } = e, c = i.length > 0 ? Ke(s ?? []) : s ?? [], o = D(t, c), d = await b(r, n);
   return await o.pipe(d.bindTools(i)).invoke(a ?? {});
-}, Je = p.object({
-  name: p.string(),
-  description: p.string(),
-  valueType: p.string(),
-  alias: p.string()
-}), Xe = p.object({
-  fields: p.array(Je)
+}, Je = h.object({
+  name: h.string(),
+  description: h.string(),
+  valueType: h.string(),
+  alias: h.string()
+}), Xe = h.object({
+  fields: h.array(Je)
 });
-function j(t, e) {
+function _(e, t) {
   const r = /* @__PURE__ */ new Map();
-  for (const n of t.fields) {
-    const s = e.fields.find((i) => i.name === n.name), a = {
+  for (const n of e.fields) {
+    const s = t.fields.find((i) => i.name === n.name), a = {
       name: n.name,
       type: n.type,
       alias: s?.alias ?? n.alias ?? "",
       description: s?.description ?? n.description ?? "",
       valueType: s?.valueType ?? n.valueType ?? "",
-      domain: t.getFieldDomain(n.name) ?? void 0
+      domain: e.getFieldDomain(n.name) ?? void 0
     };
     r.set(n.name, a);
   }
   return r;
 }
-const Qe = async (t) => {
-  const r = await T("field_descriptions_prompt"), n = t.fields.filter((i) => !(i.alias && i.description)).map((i) => {
-    const { name: c, type: o, alias: d, description: m } = i;
-    return [`Name: ${c}`, `Type: ${o}`, `Alias: ${d}`, `Description: ${m ?? "N/A"}`].join(", ");
+const Qe = async (e) => {
+  const r = await C("field_descriptions_prompt"), n = e.fields.filter((i) => !(i.alias && i.description)).map((i) => {
+    const { name: c, type: o, alias: d, description: u } = i;
+    return [`Name: ${c}`, `Type: ${o}`, `Alias: ${d}`, `Description: ${u ?? "N/A"}`].join(", ");
   }).join(`
 `);
   if (n.length === 0)
-    return j(t, { fields: [] });
+    return _(e, { fields: [] });
   const s = {
-    existingItemTitle: t.portalItem?.title,
-    existingItemDescription: t.portalItem?.description,
-    existingLayerTitle: t.title,
-    existingLayerDescription: t.portalItem?.description,
+    existingItemTitle: e.portalItem?.title,
+    existingItemDescription: e.portalItem?.description,
+    existingLayerTitle: e.title,
+    existingLayerDescription: e.portalItem?.description,
     fieldInformation: n
   }, a = await te({
     promptText: r,
     schema: Xe,
     inputVariables: s
   });
-  return j(t, a);
-}, Ye = p.object({
-  title: p.string(),
-  description: p.string(),
-  name: p.string().nullable()
-}), Ze = async (t, e) => {
-  const n = await T("layer_descriptions_prompt"), s = Array.from(e.values()), a = {
+  return _(e, a);
+}, Ye = h.object({
+  title: h.string(),
+  description: h.string(),
+  name: h.string().nullable()
+}), Ze = async (e, t) => {
+  const n = await C("layer_descriptions_prompt"), s = Array.from(t.values()), a = {
     fieldInformation: JSON.stringify(s, null, 2),
-    existingLayerTitle: t.title,
-    existingLayerDescription: t.portalItem?.description,
-    existingLayerSnippet: t.portalItem?.snippet,
-    layerGeometryType: t.geometryType
+    existingLayerTitle: e.title,
+    existingLayerDescription: e.portalItem?.description,
+    existingLayerSnippet: e.portalItem?.snippet,
+    layerGeometryType: e.geometryType
   };
   return { ...await te({
     promptText: n,
     schema: Ye,
     inputVariables: a
-  }), name: t.title ?? null };
-}, et = async (t) => {
-  const e = t.allLayers.toArray(), r = [], n = /* @__PURE__ */ new Map();
-  for (const s of e)
+  }), name: e.title ?? null };
+}, et = async (e) => {
+  const t = e.allLayers.toArray(), r = [], n = /* @__PURE__ */ new Map();
+  for (const s of t)
     if (s instanceof O) {
       const a = (async () => {
         const i = await Qe(s), c = await Ze(s, i);
@@ -792,9 +824,9 @@ const Qe = async (t) => {
       r.push(a);
     }
   return await Promise.all(r), n;
-}, ft = async (t) => {
-  await H.whenOnce(() => t.ready);
-  const e = await et(t.map), { layers: r } = await tt(e), n = {
+}, ft = async (e) => {
+  await H.whenOnce(() => e.ready);
+  const t = await et(e.map), { layers: r } = await tt(t), n = {
     schemaVersion: X,
     modified: Date.now(),
     embeddings: {
@@ -803,7 +835,7 @@ const Qe = async (t) => {
       dimensions: w,
       templates: {
         layer: A,
-        field: C
+        field: F
       }
     },
     layers: r
@@ -811,16 +843,16 @@ const Qe = async (t) => {
   if (!s.success)
     throw console.error("Schema Mismatch:", s.error.format()), new Error("Webmap embedding generation failed validation.");
   return s.data;
-}, tt = async (t) => {
-  const e = [], r = [];
-  for (const [i, { fieldRegistry: c, layerItem: o }] of t.entries()) {
-    const d = U(A, {
+}, tt = async (e) => {
+  const t = [], r = [];
+  for (const [i, { fieldRegistry: c, layerItem: o }] of e.entries()) {
+    const d = P(A, {
       name: o.name,
       title: o.title,
       description: o.description
     });
-    e.push(d);
-    const m = {
+    t.push(d);
+    const u = {
       id: i,
       name: o.name ?? "",
       title: o.title,
@@ -828,32 +860,32 @@ const Qe = async (t) => {
       vector: [],
       fields: []
     };
-    for (const [, g] of c.entries()) {
-      const y = U(C, {
-        name: g.name,
-        alias: g.alias,
-        description: g.description
+    for (const [, m] of c.entries()) {
+      const y = P(F, {
+        name: m.name,
+        alias: m.alias,
+        description: m.description
       });
-      e.push(y), m.fields.push({
-        name: g.name,
-        alias: g.alias,
-        description: g.description,
+      t.push(y), u.fields.push({
+        name: m.name,
+        alias: m.alias,
+        description: m.description,
         vector: []
       });
     }
-    r.push(m);
+    r.push(u);
   }
-  const n = await B(e);
+  const n = await B(t);
   let s = 0;
   return { layers: r.map((i) => (i.vector = n[s++], i.fields.forEach((c) => {
     c.vector = n[s++];
   }), i)) };
-}, U = (t, e) => t.replace(/\{(\w+)\}/gu, (r, n) => e[n] ?? ""), yt = (t, e) => {
-  if (t.length !== e.length)
+}, P = (e, t) => e.replace(/\{(\w+)\}/gu, (r, n) => t[n] ?? ""), yt = (e, t) => {
+  if (e.length !== t.length)
     throw new Error("Vectors must be the same length");
   let r = 0, n = 0, s = 0;
-  for (let c = 0; c < t.length; ++c) {
-    const o = t[c], d = e[c];
+  for (let c = 0; c < e.length; ++c) {
+    const o = e[c], d = t[c];
     r += o * d, n += o * o, s += d * d;
   }
   const a = Math.sqrt(n * s);
@@ -865,12 +897,12 @@ const Qe = async (t) => {
 export {
   ee as Orchestrator,
   yt as cosineSimilarity,
-  x as createChatModel,
+  b as createChatModel,
   ft as createWebmapEmbeddings,
   B as getEmbeddings,
   te as invokeStructuredPrompt,
   pt as invokeTextPrompt,
   ht as invokeToolPrompt,
-  h as sendTraceMessage,
-  ut as sendUXSuggestion
+  f as sendTraceMessage,
+  gt as sendUXSuggestion
 };

package/dist/{intent_prompt-DULnCkLt.js → intent_prompt-BSRo2YLj.js}

@@ -19,6 +19,11 @@ Return either:
   3. \`requiresFollowUp\` — whether another orchestration step will likely be needed after this agent succeeds
 - or \`null\` if no registered agent applies
 
+Important
+
+- Return null only when the request is clearly outside the scope of all registered agents.
+- If any agent can take the next useful step, select the best one instead of returning null.
+
 Latest user request:
 {userRequest}
 
@@ -34,12 +39,11 @@ Each step has:
 - agentId: string
 - assignedTask: string
 - summary: string
-- status: "success" | "failed" | "partial"
+- status: "success" | "failed" | "unknown"
 
 Use prior steps to:
 
 - Avoid repeating work that has already succeeded
-- Continue or refine steps that were partial
 - Retry or adjust steps that failed when appropriate
 
 {priorSteps}
@@ -52,6 +56,9 @@ Rules:
 - Do not plan the full workflow up front. Only decide the next best step.
 - Prefer an agent that can directly complete the user’s request.
 - Only break the request into multiple steps when necessary.
+- When multiple agents could help, choose the best fit instead of returning \`null\`.
+- Base the choice on the registered agent descriptions, not on whether the user used exact matching keywords.
+- If no agent can fully complete the request, but one agent can take the next useful step, choose that agent and set requiresFollowUp to true.
 
 Assigned Task Guidelines (IMPORTANT):
 

package/dist/types/types.d.ts

@@ -62,7 +62,7 @@ export interface AgentExecutionContext {
     userRequest: string;
     assignedTask: string;
     messages: ChatHistory;
-    priorSteps?: PriorStep[];
+    priorSteps: PriorStep[];
 }
 export interface PriorStep {
     agentId: string;
@@ -71,8 +71,8 @@ export interface PriorStep {
     status: AgentStatus;
 }
 export interface AgentResult {
-    outputMessage?: string;
-    summary: string;
     status: AgentStatus;
+    outputMessage?: string;
+    summary?: string;
 }
-export type AgentStatus = "failed" | "partial" | "success";
+export type AgentStatus = "failed" | "success" | "unknown";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcgis/ai-orchestrator",
-  "version": "5.1.0-next.84",
+  "version": "5.1.0-next.86",
   "description": "ArcGIS AI Orchestrator Package",
   "homepage": "https://developers.arcgis.com/javascript/latest/",
   "type": "module",