@arcgis/ai-orchestrator 5.1.0-next.67 → 5.1.0-next.69

package/dist/dispatcherAgent/state/dispatcherGraphState.d.ts

@@ -1,7 +1,8 @@
 import { AgentExecutionContext } from '../../types/types';
 export declare const DispatcherGraphState: import('@langchain/langgraph').AnnotationRoot<{
     agentExecutionContext: import('@langchain/langgraph').BaseChannel<AgentExecutionContext, AgentExecutionContext | import('@langchain/langgraph').OverwriteValue<AgentExecutionContext>, unknown>;
-    pendingIntents: import('@langchain/langgraph').BaseChannel<string[], string[] | import('@langchain/langgraph').OverwriteValue<string[]>, unknown>;
     currentIntent: import('@langchain/langgraph').BaseChannel<string, string | import('@langchain/langgraph').OverwriteValue<string>, unknown>;
+    requiresFollowUp: import('@langchain/langgraph').BaseChannel<boolean, boolean | import('@langchain/langgraph').OverwriteValue<boolean>, unknown>;
+    stepCount: import('@langchain/langgraph').BaseChannel<number, number | import('@langchain/langgraph').OverwriteValue<number>, unknown>;
 }>;
 export type DispatcherGraphStateType = typeof DispatcherGraphState.State;

package/dist/index.d.ts

@@ -4,6 +4,6 @@ export { invokeTextPrompt, invokeStructuredPrompt, invokeToolPrompt } from './pr
 export { createWebmapEmbeddings } from './embeddings/webmapEmbeddings';
 export { getEmbeddings } from './embeddings/embeddingsUtil';
 export { cosineSimilarity } from './embeddings/cosineSimilarity';
-export type { CustomConfigurableType, VectorSearchFieldResults, LayersAndFieldsRegistry, Services, FieldInfo, FieldStatistics, ChatHistory, AgentExecutionContext, } from './types/types';
+export type { CustomConfigurableType, VectorSearchFieldResults, LayersAndFieldsRegistry, Services, FieldInfo, FieldStatistics, ChatHistory, AgentExecutionContext, AgentStatus, PriorStep, } from './types/types';
 export type { UiInterrupt } from './hitl/types';
 export type { AgentRegistration, AgentWithContext } from './registry/agentRegistry';

package/dist/index.js

@@ -1,65 +1,66 @@
-import R from "@arcgis/core/identity/IdentityManager.js";
+import I from "@arcgis/core/identity/IdentityManager.js";
 import x from "@arcgis/core/portal/Portal.js";
-import { Annotation as b, StateGraph as Z, START as ee, END as te, MemorySaver as ne } from "@langchain/langgraph/web";
-import { HumanMessage as W, AIMessage as N, isAIMessage as re, isToolMessage as se } from "@langchain/core/messages";
+import { Annotation as b, StateGraph as te, START as ne, END as re, MemorySaver as se } from "@langchain/langgraph/web";
+import { HumanMessage as W, AIMessage as N, isAIMessage as ie, isToolMessage as ae } from "@langchain/core/messages";
 import { dispatchCustomEvent as P } from "@langchain/core/callbacks/dispatch/web";
-import p, { z as d } from "zod";
-import { SystemMessagePromptTemplate as ie, ChatPromptTemplate as ae } from "@langchain/core/prompts";
-import { OpenAIEmbeddings as oe, ChatOpenAI as ce } from "@langchain/openai";
-import * as U from "@arcgis/core/core/reactiveUtils.js";
+import u, { z as d } from "zod";
+import { SystemMessagePromptTemplate as oe, ChatPromptTemplate as ce } from "@langchain/core/prompts";
+import { OpenAIEmbeddings as de, ChatOpenAI as le } from "@langchain/openai";
+import * as q from "@arcgis/core/core/reactiveUtils.js";
 import H from "@arcgis/core/layers/FeatureLayer.js";
-import de from "@arcgis/core/request.js";
-const q = {
+import me from "@arcgis/core/request.js";
+const O = {
   advanced: "gpt-5.2",
-  default: "gpt-5-mini"
+  default: "gpt-5-mini",
+  fast: "gpt-5.4-nano"
 }, S = {
   default: "text-embedding-ada-002"
-}, M = /* @__PURE__ */ new Map();
-let E = null;
-const le = () => {
+}, E = /* @__PURE__ */ new Map();
+let v = null;
+const pe = () => {
   const t = x.getDefault().helperServices;
   if (!t?.aiModels?.url)
     throw new Error("AI Models Service URL is not defined in the portal's helper services.");
   return t.aiModels.url;
-}, O = async (e) => {
-  const t = le();
-  M.size === 0 && (E || (E = (async () => {
+}, V = async (e) => {
+  const t = pe();
+  E.size === 0 && (v || (v = (async () => {
     try {
       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));
+      (await n.json()).models.forEach((i) => E.set(i.name, i));
     } catch (n) {
-      throw E = null, n;
+      throw v = null, n;
     }
-  })()), await E);
-  const r = M.get(e);
+  })()), await v);
+  const r = E.get(e);
   if (!r)
     throw new Error(`Model '${e}' is not available in the discovery service.`);
   return r.endpoint;
-}, me = async (e = "default") => await O(q[e]), V = async (e = "default") => await O(S[e]), ge = async (e) => {
-  const t = await pe(), r = await V("default"), n = x.getDefault(), a = (await R.getCredential(`${n.url}/sharing`)).token, i = {
+}, ge = async (e = "default") => await V(O[e]), z = async (e = "default") => await V(S[e]), ue = async (e) => {
+  const t = await he(), r = await z("default"), n = x.getDefault(), i = (await I.getCredential(`${n.url}/sharing`)).token, a = {
     type: "generateEmbeddings",
     webmapEmbeddings: e,
-    auth: { apiUrl: r, token: a }
+    auth: { apiUrl: r, token: i }
   };
-  return t.postMessage(i), await new Promise((c, o) => {
-    const l = (g) => {
-      g.data === "completed" && (t.removeEventListener("message", l), c());
-    }, m = (g) => {
-      t.removeEventListener("message", l), o(g instanceof Error ? g : new Error("Embeddings worker error"));
+  return t.postMessage(a), await new Promise((c, o) => {
+    const l = (p) => {
+      p.data === "completed" && (t.removeEventListener("message", l), c());
+    }, m = (p) => {
+      t.removeEventListener("message", l), o(p instanceof Error ? p : new Error("Embeddings worker error"));
     };
     t.addEventListener("message", l), t.addEventListener("error", m, { once: !0 });
   }), t;
-}, pe = async () => {
+}, he = async () => {
   {
     const e = (await import("./embeddings.worker-GH7zdYqF.js")).default;
     return new e();
   }
-}, L = (e, t) => t, ue = (e, t) => ({
+}, D = (e, t) => t, fe = (e, t) => ({
   ...e,
   ...t
-}), he = b.Root({
+}), ye = b.Root({
   agentExecutionContext: b({
     default: () => ({
       userRequest: "",
@@ -67,54 +68,60 @@ const le = () => {
       priorSteps: [],
       messages: []
     }),
-    reducer: ue
-  }),
-  pendingIntents: b({
-    default: () => [],
-    reducer: L
+    reducer: fe
   }),
   currentIntent: b({
     default: () => "none",
-    reducer: L
+    reducer: D
+  }),
+  requiresFollowUp: b({
+    default: () => !0,
+    reducer: D
+  }),
+  stepCount: b({
+    default: () => 0,
+    reducer: (e, t) => t ?? e + 1
   })
-}), f = async (e, t) => {
+}), h = async (e, t) => {
   await P("trace_message", e, t);
-}, st = async (e, t) => {
+}, ot = async (e, t) => {
   await P("graph_ux_suggestion", e, t);
-}, fe = (e) => {
-  e.currentIntent = "none", e.pendingIntents = [];
-}, ye = async (e, t) => {
+}, we = (e) => {
+  e.currentIntent = "none";
+}, be = async (e, t) => {
   if (e.agentExecutionContext.userRequest) {
     const n = new W(e.agentExecutionContext.userRequest.trim());
-    e.agentExecutionContext.messages = [...e.agentExecutionContext.messages, n], fe(e);
+    e.agentExecutionContext.messages = [...e.agentExecutionContext.messages, n], we(e);
   }
   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;
-}, we = async (e, t) => (await f({ text: "Exiting..." }, t), e), ve = (e) => {
-  if (e.pendingIntents.length === 0)
-    return {
-      ...e,
-      currentIntent: "none"
-    };
-  const [t, ...r] = e.pendingIntents;
+  return await h({ text: `Available agents: ${[...r].join(", ")}` }, t), await h({ text: "Analyzing user input" }, t), e;
+}, ve = async (e, t) => (await h({ text: "Exiting..." }, t), e), F = 4e3, L = (e) => {
+  if (typeof e != "string")
+    return;
+  const t = e.trim();
+  return t || void 0;
+}, $ = (e) => e === "failed" || e === "partial" || e === "success", xe = (e) => e === "failed" ? "Agent failed without a summary." : e === "partial" ? "Agent partially completed without a summary." : "Agent completed without a summary.", Ee = (e, t) => {
+  const r = L(t?.outputMessage), n = L(t?.summary), s = t?.status;
+  $(s) || console.warn(`Registered agent "${e}" returned an invalid or missing status:`, s);
+  const i = $(s) ? s : r || n ? "partial" : "failed";
   return {
-    ...e,
-    currentIntent: t,
-    pendingIntents: r
+    outputMessage: r,
+    summary: n ?? r ?? xe(i),
+    status: i
   };
-}, _ = 4e3, be = async (e, t) => {
+}, Ie = 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: ${e.currentIntent}`), e;
-  await f({ text: `Executing registered agent: ${s.agent.name}` }, t);
-  const a = {
+  await h({ text: `Executing registered agent: ${s.agent.name}` }, t);
+  const i = {
     ...t ?? {},
     configurable: {
       ...r ?? {},
       agentId: s.agent.id,
       context: s.getContext ? await s.getContext() : void 0
     }
-  }, i = await s.agent.createGraph().compile().invoke(
+  }, a = await s.agent.createGraph().compile().invoke(
     {
       agentExecutionContext: {
         ...e.agentExecutionContext,
@@ -122,32 +129,38 @@ const le = () => {
         priorSteps: [...e.agentExecutionContext.priorSteps ?? []]
       }
     },
-    a
+    i
   );
-  await f({ text: `Finished executing registered agent: ${s.agent.name}` }, t);
-  const c = typeof i?.outputMessage == "string" ? i.outputMessage.trim() : "", o = {
-    outputMessage: c,
-    // TODO: handle summary and status in the agent graph and return here
-    summary: typeof i?.summary == "string" ? i.summary.trim() : c,
-    status: typeof i?.status == "string" ? i.status : "partial"
-  }, l = typeof o?.outputMessage == "string" ? o.outputMessage.trim() : "";
-  if (!l)
-    return e;
-  const m = l.length > _ ? `${l.slice(0, _ - 14)}
-[truncated]` : l;
+  await h({ text: `Finished executing registered agent: ${s.agent.name}` }, t);
+  const c = Ee(s.agent.name, a), o = c.outputMessage, l = [...e.agentExecutionContext.messages];
+  if (o) {
+    const m = o.length > F ? `${o.slice(0, F - 14)}
+[truncated]` : o;
+    l.push(new N(m));
+  }
   return {
     ...e,
+    stepCount: e.stepCount + 1,
     agentExecutionContext: {
       ...e.agentExecutionContext,
-      messages: [...e.agentExecutionContext.messages, new N(m)]
+      messages: l,
+      priorSteps: [
+        ...e.agentExecutionContext.priorSteps ?? [],
+        {
+          agentId: s.agent.id,
+          assignedTask: e.agentExecutionContext.assignedTask,
+          summary: c.summary,
+          status: c.status
+        }
+      ]
     }
   };
-}, Ee = (e, t, r) => {
+}, Se = (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: " + t + (t.split("/").length !== r ? ". Note that variables only represent file names one level deep." : ""))));
+  return n ? typeof n == "function" ? n() : Promise.resolve(n) : new Promise((s, i) => {
+    (typeof queueMicrotask == "function" ? queueMicrotask : setTimeout)(i.bind(null, /* @__PURE__ */ new Error("Unknown variable dynamic import: " + t + (t.split("/").length !== r ? ". Note that variables only represent file names one level deep." : ""))));
   });
-}, k = async (e) => (await Ee(/* @__PURE__ */ Object.assign({ "./field_descriptions_prompt.md": () => import("./field_descriptions_prompt-haMV_aoG.js"), "./intent_prompt.md": () => import("./intent_prompt-CRmsldou.js"), "./layer_descriptions_prompt.md": () => import("./layer_descriptions_prompt-NAaKWdJi.js") }), `./${e}.md`, 2)).default, xe = (e, t = 3) => e.filter((r) => r.type === "human").slice(-t), Ie = (e) => {
+}, M = async (e) => (await Se(/* @__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") }), `./${e}.md`, 2)).default, Me = (e, t = 3) => e.filter((r) => r.type === "human").slice(-t), Re = (e) => {
   let t = -1;
   for (let r = e.length - 1; r >= 0; r--)
     if (e[r] instanceof W) {
@@ -156,123 +169,137 @@ const le = () => {
     }
   return t === -1 ? "" : e.slice(t + 1).filter((r) => r instanceof N).map((r) => r.content).join(`
 `);
-}, z = (e) => async (t, r) => {
+}, G = (e) => async (t, r) => {
   const n = new Headers(r?.headers);
   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
   });
-}, D = async (e = "default", t = 0) => {
-  const r = x.getDefault(), n = await R.getCredential(`${r.url}/sharing`), s = q[e], a = await me(e);
-  return new ce({
+}, R = async (e = "default", t = 0) => {
+  const r = x.getDefault(), n = await I.getCredential(`${r.url}/sharing`), s = O[e], i = await ge(e);
+  return new le({
     modelName: s,
     apiKey: "dummy-key",
     // 5-mini does not support temperature parameter
     ...e !== "default" && { temperature: t },
     configuration: {
-      baseURL: a,
-      fetch: z(n.token)
+      baseURL: i,
+      fetch: G(n.token)
     }
   });
-}, Me = async (e = "default") => {
-  const t = x.getDefault(), r = await R.getCredential(`${t.url}/sharing`), n = S[e], s = await V(e);
-  return new oe({
+}, ke = async (e = "default") => {
+  const t = x.getDefault(), r = await I.getCredential(`${t.url}/sharing`), n = S[e], s = await z(e);
+  return new de({
     modelName: n,
     apiKey: "dummy-key",
     configuration: {
       baseURL: s,
-      fetch: z(r.token)
+      fetch: G(r.token)
     },
     batchSize: 2048,
     maxConcurrency: 10
   });
-}, Re = (e) => {
+}, Te = (e) => {
   const t = /* @__PURE__ */ new Set();
   for (const n of e)
-    if (re(n)) {
+    if (ie(n)) {
       const s = n;
-      s.tool_calls && s.tool_calls.length > 0 && s.tool_calls.forEach((a) => {
-        a.id && t.add(a.id);
+      s.tool_calls && s.tool_calls.length > 0 && s.tool_calls.forEach((i) => {
+        i.id && t.add(i.id);
       });
     }
   return e.filter((n) => {
-    if (se(n)) {
+    if (ae(n)) {
       const s = n;
       return t.has(s.tool_call_id);
     }
     return !0;
   });
-}, T = (e, t) => {
-  const r = ie.fromTemplate(e);
-  return ae.fromMessages([r, ...t]);
-}, Se = async (e) => {
-  const { promptText: t, modelTier: r, temperature: n, messages: s } = e, a = T(t, s ?? []), i = await D(r, n);
-  return a.pipe(i);
-}, it = async (e) => {
-  const { promptText: t, modelTier: r = "default", temperature: n = 0, messages: s, inputVariables: a } = e, c = await (await Se({
+}, k = (e, t) => {
+  const r = oe.fromTemplate(e);
+  return ce.fromMessages([r, ...t]);
+}, Ce = async (e) => {
+  const { promptText: t, modelTier: r, temperature: n, messages: s } = e, i = k(t, s ?? []), a = await R(r, n);
+  return i.pipe(a);
+}, ct = async (e) => {
+  const { promptText: t, modelTier: r = "default", temperature: n = 0, messages: s, inputVariables: i } = e, c = await (await Ce({
     promptText: t,
     modelTier: r,
     temperature: n,
     messages: s
-  })).invoke(a ?? {});
+  })).invoke(i ?? {});
   if (typeof c == "string")
     return c;
   const o = c.content;
   return typeof o == "string" ? o : JSON.stringify(o);
-}, A = async (e) => {
-  const { promptText: t, modelTier: r = "default", temperature: n = 0, messages: s, inputVariables: a, schema: i } = e, c = T(t, s ?? []), l = (await D(r, n)).withStructuredOutput(i);
-  return await c.pipe(l).invoke(a ?? {});
-}, at = async (e) => {
-  const { promptText: t, modelTier: r = "default", temperature: n = 0, messages: s, inputVariables: a, tools: i } = e, c = i.length > 0 ? Re(s ?? []) : s ?? [], o = T(t, c), l = await D(r, n);
-  return await o.pipe(l.bindTools(i)).invoke(a ?? {});
-}, ke = d.object({
+}, T = async (e) => {
+  const { promptText: t, modelTier: r = "default", temperature: n = 0, messages: s, inputVariables: i, schema: a } = e, c = k(t, s ?? []), l = (await R(r, n)).withStructuredOutput(a);
+  return await c.pipe(l).invoke(i ?? {});
+}, dt = async (e) => {
+  const { promptText: t, modelTier: r = "default", temperature: n = 0, messages: s, inputVariables: i, tools: a } = e, c = a.length > 0 ? Te(s ?? []) : s ?? [], o = k(t, c), l = await R(r, n);
+  return await o.pipe(l.bindTools(a)).invoke(i ?? {});
+}, Ae = d.object({
   id: d.string().min(1),
   name: d.string().min(1),
   description: d.string().min(1)
 });
-d.array(ke);
+d.array(Ae);
 const De = (e) => {
   const t = e.map((n) => n.id), r = d.enum(t);
   return d.object({
-    intents: d.array(r)
+    intent: r.nullable(),
+    assignedTask: d.string().nullable(),
+    requiresFollowUp: d.boolean()
   });
-}, Te = async (e, t) => {
+}, Fe = async (e, t) => {
   try {
-    await f({ text: "Asking LLM to detect intents" }, t);
-    const n = await k("intent_prompt"), i = (t?.configurable?.services.agentRegistry?.list() ?? []).map(({ agent: y }) => ({
-      id: y.id,
-      name: y.name,
-      description: y.description
+    await h({ text: "Asking LLM to detect intent" }, t);
+    const n = await M("intent_prompt"), a = (t?.configurable?.services.agentRegistry?.list() ?? []).map(({ agent: g }) => ({
+      id: g.id,
+      name: g.name,
+      description: g.description
     }));
-    if (!i.length)
-      return await f({ text: "No agents registered; skipping intent detection" }, t), {
+    if (!a.length)
+      return await h({ text: "No agents registered; skipping intent detection" }, t), {
         ...e,
-        currentIntent: "none",
-        pendingIntents: []
+        currentIntent: "none"
       };
-    const c = i.map((y) => JSON.stringify(y)).join(`
-`), o = i.length, l = De(i), m = {
-      maxIntents: o,
-      registeredAgents: c
-    }, g = await A({
+    const c = a.map((g) => JSON.stringify(g)).join(`
+`), o = De(a), l = {
+      registeredAgents: c,
+      priorSteps: e.agentExecutionContext.priorSteps,
+      userRequest: e.agentExecutionContext.userRequest
+    }, m = await T({
       promptText: n,
-      schema: l,
-      messages: xe(e.agentExecutionContext.messages),
-      inputVariables: m
-    }), w = /* @__PURE__ */ new Set(), h = (g.intents ?? []).filter((y) => w.has(y) ? !1 : (w.add(y), !0)).slice(0, o), u = h[0] ?? "none", I = {
+      schema: o,
+      messages: Me(e.agentExecutionContext.messages),
+      inputVariables: l
+    });
+    console.log("Raw intent detection output:", m);
+    const p = m.intent ?? "none", y = {
       ...e,
-      currentIntent: u,
-      pendingIntents: h
+      currentIntent: p,
+      requiresFollowUp: m.requiresFollowUp,
+      agentExecutionContext: {
+        ...e.agentExecutionContext,
+        assignedTask: m.assignedTask ?? ""
+      }
     };
-    return await f({ text: `Intents came back as: ${h.join(", ") || "none"}` }, t), I;
+    return await h({ text: `Intent came back as: ${p}` }, t), await h(
+      { text: `Agent picked: ${p}
+Task Assigned: ${m.assignedTask ?? ""}` },
+      t
+    ), y;
   } catch (r) {
-    throw await f({ text: "Error during intent detection" }, t), new Error(`Error during intent detection: ${r instanceof Error ? r.message : String(r)}`);
+    throw await h({ text: "Error during intent detection" }, t), new Error(`Error during intent detection: ${r instanceof Error ? r.message : String(r)}`);
   }
-}, Ae = () => new Z(he).addNode("ingestInput", ye).addNode("intentLLM", Te).addNode("intentDispatcher", ve).addNode("executeRegisteredAgent", be).addNode("exit", we).addEdge(ee, "ingestInput").addEdge("ingestInput", "intentLLM").addEdge("intentLLM", "intentDispatcher").addConditionalEdges(
-  "intentDispatcher",
-  (t) => t.currentIntent === "none" ? "exit" : "executeRegisteredAgent"
-).addEdge("executeRegisteredAgent", "intentDispatcher").addEdge("exit", te);
-class Ce {
+}, _ = 3, Le = () => new te(ye).addNode("ingestInput", be).addNode("intentLLM", Fe).addNode("executeRegisteredAgent", Ie).addNode("exit", ve).addEdge(ne, "ingestInput").addEdge("ingestInput", "intentLLM").addConditionalEdges("intentLLM", (t) => t.currentIntent === "none" ? "exit" : "executeRegisteredAgent").addConditionalEdges("executeRegisteredAgent", (t) => (console.log("[Dispatcher][executeRegisteredAgent]", {
+  intent: t.currentIntent,
+  followUp: t.requiresFollowUp,
+  step: t.stepCount,
+  maxSteps: _
+}), !t.requiresFollowUp || t.stepCount >= _ ? "exit" : "intentLLM")).addEdge("exit", re);
+class $e {
   constructor() {
     this.agentRegistry = /* @__PURE__ */ new Map();
   }
@@ -289,7 +316,7 @@ class Ce {
     return [...this.agentRegistry.values()];
   }
 }
-class Fe {
+class _e {
   /**
    * Create a new InterruptHandler tied to a specific compiled graph and config.
    */
@@ -336,23 +363,23 @@ class Fe {
     this.rejectWait && (this.rejectWait(new Error("Request cancelled by user.")), this.resolveWait = void 0, this.rejectWait = void 0);
   }
 }
-const G = async (e) => {
+const K = async (e) => {
   try {
-    return await (await Me()).embedDocuments(e);
+    return await (await ke()).embedDocuments(e);
   } catch (t) {
     throw console.error("Failed to generate embeddings:", t), t;
   }
-}, K = async (e, t) => {
+}, B = async (e, t) => {
   const r = t.get(e);
   if (r)
     return r;
-  const n = await G([e]);
+  const n = await K([e]);
   return t.set(e, n[0]), n[0];
 };
-async function Le(e, t, r, n) {
-  const s = `req-${Date.now()}`, i = {
+async function je(e, t, r, n) {
+  const s = `req-${Date.now()}`, a = {
     type: "layerSearch",
-    precomputedEmbedding: n ? await K(e, n) : void 0,
+    precomputedEmbedding: n ? await B(e, n) : void 0,
     requestId: s,
     minScore: r
   };
@@ -360,10 +387,10 @@ async function Le(e, t, r, n) {
     const o = (l) => {
       l.data.requestId === s && c(l.data.results);
     };
-    t.addEventListener("message", o, { once: !0 }), t.postMessage(i);
+    t.addEventListener("message", o, { once: !0 }), t.postMessage(a);
   });
 }
-function _e(e) {
+function Ue(e) {
   const { worker: t } = e;
   return {
     async searchLayers({
@@ -371,68 +398,68 @@ function _e(e) {
       minScore: n,
       embeddingCache: s
     }) {
-      return await Le(r, t, n, s);
+      return await je(r, t, n, s);
     }
   };
 }
-const $e = async ({
+const We = async ({
   combinedQuery: e,
   layerIds: t,
   embeddingsWorker: r,
   minScore: n,
   topResults: s,
-  embeddingCache: a
+  embeddingCache: i
 }) => {
-  const i = `req-${Date.now()}`, c = a ? await K(e, a) : void 0, o = {
+  const a = `req-${Date.now()}`, c = i ? await B(e, i) : void 0, o = {
     type: "fieldSearch",
     layerIdForFieldsSearch: t,
     precomputedEmbedding: c,
-    requestId: i,
+    requestId: a,
     minScore: n,
     topResults: s
   };
   return await new Promise((l) => {
-    const m = (g) => {
-      if (g.data.requestId !== i)
+    const m = (p) => {
+      if (p.data.requestId !== a)
         return;
-      const w = g.data.results.map(({ layerId: h, results: u }) => ({
-        layerId: h,
-        results: u
+      const y = p.data.results.map(({ layerId: g, results: f }) => ({
+        layerId: g,
+        results: f
       }));
-      l(w);
+      l(y);
     };
     r.addEventListener("message", m, { once: !0 }), r.postMessage(o);
   });
 };
-function je(e) {
+function Ne(e) {
   const { worker: t } = e;
   return {
-    async searchFields({ text: r, layerIds: n, minScore: s, topResults: a, embeddingCache: i }) {
-      return await $e({
+    async searchFields({ text: r, layerIds: n, minScore: s, topResults: i, embeddingCache: a }) {
+      return await We({
         combinedQuery: r,
         layerIds: n,
         embeddingsWorker: t,
         minScore: s,
-        topResults: a,
-        embeddingCache: i
+        topResults: i,
+        embeddingCache: a
       });
     }
   };
 }
-const B = "0.1", v = 1536, J = "openai", X = S.default, C = `Name: {name}
+const J = "0.1", w = 1536, X = "openai", Q = S.default, C = `Name: {name}
 Title: {title}
-Description: {description}`, F = `Name: {name}
+Description: {description}`, A = `Name: {name}
 Alias: {alias}
-Description: {description}`, Q = d.object({
-  schemaVersion: d.literal(B),
+Description: {description}`, Y = d.object({
+  schemaVersion: d.literal(J),
   modified: d.number().int().nonnegative(),
   embeddings: d.object({
-    modelProvider: d.literal(J),
-    model: d.literal(X),
-    dimensions: d.literal(v),
+    modelProvider: d.literal(X),
+    model: d.literal(Q),
+    dimensions: d.literal(w),
     templates: d.object({
       layer: d.string().default(C),
-      field: d.string().default(F)
+      field: d.string().default(A)
     })
   }),
   layers: d.array(
@@ -441,49 +468,49 @@ Description: {description}`, Q = d.object({
       name: d.string().min(1),
       title: d.string().catch(""),
       description: d.string().catch(""),
-      vector: d.array(d.number()).length(v, {
-        message: `Layer vector must be exactly ${v} dimensions`
+      vector: d.array(d.number()).length(w, {
+        message: `Layer vector must be exactly ${w} dimensions`
       }),
       fields: d.array(
         d.object({
           name: d.string().min(1),
           alias: d.string().catch(""),
           description: d.string().catch(""),
-          vector: d.array(d.number()).length(v, {
-            message: `Field vector must be exactly ${v} dimensions`
+          vector: d.array(d.number()).length(w, {
+            message: `Field vector must be exactly ${w} dimensions`
           })
         })
       )
     })
   ).default([])
-}), We = (e) => {
-  const t = Q.safeParse(e);
+}), Pe = (e) => {
+  const t = Y.safeParse(e);
   if (!t.success)
     throw new Error("Embeddings response validation failed. Regenerate embeddings.");
   return t.data;
-}, Ne = (e, t) => {
+}, qe = (e, t) => {
   const r = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map();
   if (t.allLayers.forEach((s) => {
     s instanceof H && n.set(s.id, s);
   }), e.length !== n.size)
     throw new Error("Layer count mismatch during registry restoration. Regenerate embeddings.");
   for (const s of e) {
-    const a = n.get(s.id);
-    if (!a)
+    const i = n.get(s.id);
+    if (!i)
       throw new Error(
         `Layer with ID ${s.id} not found in the original map during registry restoration. Regenerate embeddings.`
       );
-    if (s.fields.length !== a.fields.length)
+    if (s.fields.length !== i.fields.length)
       throw new Error(
         `Field count mismatch for layer ID ${s.id} during registry restoration. Regenerate embeddings.`
       );
-    const i = {
+    const a = {
       name: s.name,
       title: s.title,
       description: s.description
     }, c = /* @__PURE__ */ new Map();
     for (const o of s.fields) {
-      const l = a.fieldsIndex.get(o.name);
+      const l = i.fieldsIndex.get(o.name);
       if (!l)
         throw new Error(
           `Field with name ${o.name} not found in the original layer ${s.id} during registry restoration. Regenerate embeddings.`
@@ -494,36 +521,36 @@ Description: {description}`, Q = d.object({
         description: o.description,
         type: l.type || "unknown",
         valueType: l.valueType || "unknown",
-        domain: a.getFieldDomain(o.name) ?? void 0
+        domain: i.getFieldDomain(o.name) ?? void 0
       });
     }
     r.set(s.id, {
-      layerItem: i,
+      layerItem: a,
       fieldRegistry: c
     });
   }
   return r;
-}, Pe = async (e) => {
+}, He = async (e) => {
   try {
-    return (await de(e, {
+    return (await me(e, {
       responseType: "json"
     })).data;
   } catch (t) {
     throw new Error(`Failed to fetch data from ${e}: ${String(t)}`);
   }
-}, Ue = async (e) => {
+}, Oe = async (e) => {
   const t = e.map;
   if (!t?.portalItem)
     throw new Error("WebMap portal item is missing.");
-  const { resources: r } = await t.portalItem.fetchResources(), n = r.find((i) => i.resource.path === "embeddings-v01.json");
+  const { resources: r } = await t.portalItem.fetchResources(), n = r.find((a) => a.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 Pe(n.resource.url);
-  return We(s);
+  const s = await He(n.resource.url);
+  return Pe(s);
 };
-class Y {
+class Z {
   constructor() {
-    this.orchestratorReady = !1, this.chatHistory = [], this.threadId = "", this.agentRegistry = new Ce(), this.streamEpoch = 0;
+    this.orchestratorReady = !1, this.chatHistory = [], this.priorSteps = [], this.threadId = "", this.agentRegistry = new $e(), this.streamEpoch = 0;
   }
   /**
    * Creates and returns an AI-ready Orchestrator instance.
@@ -531,15 +558,15 @@ class Y {
    * @returns Ready Orchestrator.
    */
   static async init(t) {
-    const r = new Y();
+    const r = new Z();
     try {
       if (t.view?.map) {
-        await U.whenOnce(() => t.view.ready);
-        const n = await Ue(t.view), s = Ne(
+        await q.whenOnce(() => t.view.ready);
+        const n = await Oe(t.view), s = qe(
           n.layers,
           t.view.map
         );
-        r.layersAndFieldsRegistry = s, r.embeddingsWorker = await ge(n);
+        r.layersAndFieldsRegistry = s, r.embeddingsWorker = await ue(n);
       }
       return t.agents?.forEach((n) => {
         r.agentRegistry.register(n);
@@ -563,8 +590,8 @@ class Y {
       throw new Error("Orchestrator has no registered agents.");
     if (++this.streamEpoch, !t.trim())
       return;
-    this.threadId = String(Date.now()), this.graph || (this.graph = Ae().compile({ checkpointer: new ne() }));
-    const r = this.embeddingsWorker ? _e({ worker: this.embeddingsWorker }) : void 0, n = this.embeddingsWorker ? je({ worker: this.embeddingsWorker }) : void 0, s = /* @__PURE__ */ new Map(), i = {
+    this.threadId = String(Date.now()), this.graph || (this.graph = Le().compile({ checkpointer: new se() }));
+    const r = this.embeddingsWorker ? Ue({ worker: this.embeddingsWorker }) : void 0, n = this.embeddingsWorker ? Ne({ worker: this.embeddingsWorker }) : void 0, s = /* @__PURE__ */ new Map(), a = {
       version: "v2",
       streamMode: "custom",
       configurable: {
@@ -581,24 +608,24 @@ class Y {
       },
       subgraphs: !0
     }, c = this.graph?.streamEvents(
-      { agentExecutionContext: { userRequest: t, messages: this.chatHistory } },
-      i
+      { agentExecutionContext: { userRequest: t, messages: this.chatHistory, priorSteps: this.priorSteps } },
+      a
     ), o = ++this.streamEpoch;
     for (yield* this.pipeStream(c, o); ; ) {
-      const h = (await this.graph.getState(i, { subgraphs: !0 })).tasks.find((u) => u.interrupts.length > 0)?.interrupts[0]?.value;
-      if (!h)
+      const g = (await this.graph.getState(a, { subgraphs: !0 })).tasks.find((f) => f.interrupts.length > 0)?.interrupts[0]?.value;
+      if (!g)
         break;
-      this.currentInterrupt = h, this.interruptHandler = new Fe(this.graph, i), yield { runId: this.threadId, timestamp: Date.now(), type: "interrupt", interrupt: h };
+      this.currentInterrupt = g, this.interruptHandler = new _e(this.graph, a), yield { runId: this.threadId, timestamp: Date.now(), type: "interrupt", interrupt: g };
       try {
-        const u = await this.interruptHandler.waitForUser(), I = ++this.streamEpoch;
-        yield* this.pipeStream(u, I);
-      } catch (u) {
-        if (u) {
+        const f = await this.interruptHandler.waitForUser(), ee = ++this.streamEpoch;
+        yield* this.pipeStream(f, ee);
+      } catch (f) {
+        if (f) {
           yield {
             runId: this.threadId,
             timestamp: Date.now(),
             type: "error",
-            error: { message: u?.message }
+            error: { message: f?.message }
           };
           return;
         }
@@ -606,19 +633,19 @@ class Y {
         return;
       }
     }
-    const m = (await this.graph.getState(i, { subgraphs: !0 })).values;
-    this.chatHistory = m.agentExecutionContext.messages.length ? m.agentExecutionContext.messages : this.chatHistory, yield {
+    const m = (await this.graph.getState(a, { subgraphs: !0 })).values;
+    this.chatHistory = m.agentExecutionContext.messages.length ? m.agentExecutionContext.messages : this.chatHistory, this.priorSteps = m.agentExecutionContext.priorSteps?.slice(-5) ?? [], yield {
       runId: this.threadId,
       timestamp: Date.now(),
       type: "completed",
-      result: { content: Ie(m.agentExecutionContext.messages) }
+      result: { content: Re(m.agentExecutionContext.messages) }
     };
   }
   /**
-   * Start a new conversation by clearing chat history.
+   * Start a new conversation by clearing chat history and prior steps.
    */
   newConversation() {
-    this.chatHistory = [];
+    this.chatHistory = [], this.priorSteps = [];
   }
   /**
    * Generic resume for any HITL interrupt.
@@ -657,18 +684,18 @@ class Y {
     this.embeddingsWorker && (this.embeddingsWorker.terminate(), this.embeddingsWorker = void 0), this.orchestratorReady = !1;
   }
 }
-const He = p.object({
-  name: p.string(),
-  description: p.string(),
-  valueType: p.string(),
-  alias: p.string()
-}), qe = p.object({
-  fields: p.array(He)
+const Ve = u.object({
+  name: u.string(),
+  description: u.string(),
+  valueType: u.string(),
+  alias: u.string()
+}), ze = u.object({
+  fields: u.array(Ve)
 });
-function $(e, t) {
+function j(e, t) {
   const r = /* @__PURE__ */ new Map();
   for (const n of e.fields) {
-    const s = t.fields.find((i) => i.name === n.name), a = {
+    const s = t.fields.find((a) => a.name === n.name), i = {
       name: n.name,
       type: n.type,
       alias: s?.alias ?? n.alias ?? "",
@@ -676,115 +703,115 @@ function $(e, t) {
       valueType: s?.valueType ?? n.valueType ?? "",
       domain: e.getFieldDomain(n.name) ?? void 0
     };
-    r.set(n.name, a);
+    r.set(n.name, i);
   }
   return r;
 }
-const Oe = async (e) => {
-  const r = await k("field_descriptions_prompt"), n = e.fields.filter((i) => !(i.alias && i.description)).map((i) => {
-    const { name: c, type: o, alias: l, description: m } = i;
+const Ge = async (e) => {
+  const r = await M("field_descriptions_prompt"), n = e.fields.filter((a) => !(a.alias && a.description)).map((a) => {
+    const { name: c, type: o, alias: l, description: m } = a;
     return [`Name: ${c}`, `Type: ${o}`, `Alias: ${l}`, `Description: ${m ?? "N/A"}`].join(", ");
   }).join(`
 `);
   if (n.length === 0)
-    return $(e, { fields: [] });
+    return j(e, { fields: [] });
   const s = {
     existingItemTitle: e.portalItem?.title,
     existingItemDescription: e.portalItem?.description,
     existingLayerTitle: e.title,
     existingLayerDescription: e.portalItem?.description,
     fieldInformation: n
-  }, a = await A({
+  }, i = await T({
     promptText: r,
-    schema: qe,
+    schema: ze,
     inputVariables: s
   });
-  return $(e, a);
-}, Ve = p.object({
-  title: p.string(),
-  description: p.string(),
-  name: p.string().nullable()
-}), ze = async (e, t) => {
-  const n = await k("layer_descriptions_prompt"), s = Array.from(t.values()), a = {
+  return j(e, i);
+}, Ke = u.object({
+  title: u.string(),
+  description: u.string(),
+  name: u.string().nullable()
+}), Be = async (e, t) => {
+  const n = await M("layer_descriptions_prompt"), s = Array.from(t.values()), i = {
     fieldInformation: JSON.stringify(s, null, 2),
     existingLayerTitle: e.title,
     existingLayerDescription: e.portalItem?.description,
     existingLayerSnippet: e.portalItem?.snippet,
     layerGeometryType: e.geometryType
   };
-  return { ...await A({
+  return { ...await T({
     promptText: n,
-    schema: Ve,
-    inputVariables: a
+    schema: Ke,
+    inputVariables: i
   }), name: e.title ?? null };
-}, Ge = async (e) => {
+}, Je = async (e) => {
   const t = e.allLayers.toArray(), r = [], n = /* @__PURE__ */ new Map();
   for (const s of t)
     if (s instanceof H) {
-      const a = (async () => {
-        const i = await Oe(s), c = await ze(s, i);
-        n.set(s.id, { layerItem: c, fieldRegistry: i });
+      const i = (async () => {
+        const a = await Ge(s), c = await Be(s, a);
+        n.set(s.id, { layerItem: c, fieldRegistry: a });
       })();
-      r.push(a);
+      r.push(i);
     }
   return await Promise.all(r), n;
-}, ot = async (e) => {
-  await U.whenOnce(() => e.ready);
-  const t = await Ge(e.map), { layers: r } = await Ke(t), n = {
-    schemaVersion: B,
+}, lt = async (e) => {
+  await q.whenOnce(() => e.ready);
+  const t = await Je(e.map), { layers: r } = await Xe(t), n = {
+    schemaVersion: J,
     modified: Date.now(),
     embeddings: {
-      modelProvider: J,
-      model: X,
-      dimensions: v,
+      modelProvider: X,
+      model: Q,
+      dimensions: w,
       templates: {
         layer: C,
-        field: F
+        field: A
       }
     },
     layers: r
-  }, s = Q.safeParse(n);
+  }, s = Y.safeParse(n);
   if (!s.success)
     throw console.error("Schema Mismatch:", s.error.format()), new Error("Webmap embedding generation failed validation.");
   return s.data;
-}, Ke = async (e) => {
+}, Xe = async (e) => {
   const t = [], r = [];
-  for (const [i, { fieldRegistry: c, layerItem: o }] of e.entries()) {
-    const l = j(C, {
+  for (const [a, { fieldRegistry: c, layerItem: o }] of e.entries()) {
+    const l = U(C, {
       name: o.name,
       title: o.title,
       description: o.description
     });
     t.push(l);
     const m = {
-      id: i,
+      id: a,
       name: o.name ?? "",
       title: o.title,
       description: o.description,
       vector: [],
       fields: []
     };
-    for (const [, g] of c.entries()) {
-      const w = j(F, {
-        name: g.name,
-        alias: g.alias,
-        description: g.description
+    for (const [, p] of c.entries()) {
+      const y = U(A, {
+        name: p.name,
+        alias: p.alias,
+        description: p.description
       });
-      t.push(w), m.fields.push({
-        name: g.name,
-        alias: g.alias,
-        description: g.description,
+      t.push(y), m.fields.push({
+        name: p.name,
+        alias: p.alias,
+        description: p.description,
         vector: []
       });
     }
     r.push(m);
   }
-  const n = await G(t);
+  const n = await K(t);
   let s = 0;
-  return { layers: r.map((i) => (i.vector = n[s++], i.fields.forEach((c) => {
+  return { layers: r.map((a) => (a.vector = n[s++], a.fields.forEach((c) => {
     c.vector = n[s++];
-  }), i)) };
-}, j = (e, t) => e.replace(/\{(\w+)\}/gu, (r, n) => t[n] ?? ""), ct = (e, t) => {
+  }), a)) };
+}, U = (e, t) => e.replace(/\{(\w+)\}/gu, (r, n) => t[n] ?? ""), mt = (e, t) => {
   if (e.length !== t.length)
     throw new Error("Vectors must be the same length");
   let r = 0, n = 0, s = 0;
@@ -792,20 +819,20 @@ const Oe = async (e) => {
     const o = e[c], l = t[c];
     r += o * l, n += o * o, s += l * l;
   }
-  const a = Math.sqrt(n * s);
-  if (a === 0)
+  const i = Math.sqrt(n * s);
+  if (i === 0)
     return 0;
-  const i = r / a;
-  return Math.max(-1, Math.min(1, i));
+  const a = r / i;
+  return Math.max(-1, Math.min(1, a));
 };
 export {
-  Y as Orchestrator,
-  ct as cosineSimilarity,
-  ot as createWebmapEmbeddings,
-  G as getEmbeddings,
-  A as invokeStructuredPrompt,
-  it as invokeTextPrompt,
-  at as invokeToolPrompt,
-  f as sendTraceMessage,
-  st as sendUXSuggestion
+  Z as Orchestrator,
+  mt as cosineSimilarity,
+  lt as createWebmapEmbeddings,
+  K as getEmbeddings,
+  T as invokeStructuredPrompt,
+  ct as invokeTextPrompt,
+  dt as invokeToolPrompt,
+  h as sendTraceMessage,
+  ot as sendUXSuggestion
 };

package/dist/intent_prompt-DULnCkLt.js

@@ -0,0 +1,77 @@
+const e = `## GIS Agent Orchestrator
+
+You are an orchestrator for an ArcGIS Maps SDK for JavaScript system.
+
+Your job is to decide the single best next agent to execute for the current step.
+
+You are given:
+
+- the latest user request
+- relevant chat history
+- the list of registered agents
+- optional prior steps from earlier agent executions
+
+Return either:
+
+- one decision with:
+  1. \`agentId\` — the next agent to execute
+  2. \`assignedTask\` — a clear, actionable task for that agent
+  3. \`requiresFollowUp\` — whether another orchestration step will likely be needed after this agent succeeds
+- or \`null\` if no registered agent applies
+
+Latest user request:
+{userRequest}
+
+Registered agents are provided in this format:
+{{id: string, name: string, description: string}}[]
+
+{registeredAgents}
+
+Prior steps performed by agents are provided:
+
+Each step has:
+
+- agentId: string
+- assignedTask: string
+- summary: string
+- status: "success" | "failed" | "partial"
+
+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}
+
+Rules:
+
+- Focus primarily on the latest user request.
+- Use relevant chat history only when the latest request clearly depends on earlier context; otherwise ignore it.
+- Use prior steps to determine what has already been attempted or completed.
+- 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.
+
+Assigned Task Guidelines (IMPORTANT):
+
+- The assignedTask should be specific, short, and directly executable by the selected agent.
+- Keep it as close as possible to the user’s request.
+- Prefer minimal transformation of the user’s wording.
+- It should be a concise restatement, not a rewritten or expanded version.
+- Do not rephrase into more detailed or formal language than the user’s request.
+- Use only information explicitly present in the user request or provided context.
+- Do not enrich, elaborate, or add unstated details.
+- Do not clarify or expand the request beyond what the user explicitly stated.
+- Do not add implementation details, UI behavior, or inferred steps.
+- The assignedTask may represent only part of the user’s full request when multiple steps are necessary.
+
+requiresFollowUp Guidelines:
+
+- requiresFollowUp should indicate a likely next agent step, not uncertainty about the current request.
+- Set requiresFollowUp to true only when another orchestration step will likely be needed after this agent succeeds.
+- Set requiresFollowUp to false when a successful result from this agent would likely complete the user-visible task.
+`;
+export {
+  e as default
+};

package/dist/models/types.d.ts

@@ -1,2 +1,2 @@
-export type ChatModelTier = "advanced" | "default";
+export type ChatModelTier = "advanced" | "default" | "fast";
 export type EmbeddingModelTier = "default";

package/dist/orchestrator/orchestrator.d.ts

@@ -23,6 +23,7 @@ export declare class Orchestrator {
     private embeddingsWorker?;
     private graph?;
     private chatHistory;
+    private priorSteps;
     private threadId;
     private agentRegistry;
     private layersAndFieldsRegistry?;
@@ -46,7 +47,7 @@ export declare class Orchestrator {
      */
     ask(userInput: string): AsyncGenerator<OrchestratorEvent>;
     /**
-     * Start a new conversation by clearing chat history.
+     * Start a new conversation by clearing chat history and prior steps.
      */
     newConversation(): void;
     /**

package/dist/types/types.d.ts

@@ -66,12 +66,13 @@ export interface AgentExecutionContext {
 }
 export interface PriorStep {
     agentId: string;
+    assignedTask: string;
     summary: string;
     status: AgentStatus;
 }
 export interface AgentResult {
-    status?: AgentStatus;
     outputMessage?: string;
-    summary?: string;
+    summary: string;
+    status: AgentStatus;
 }
 export type AgentStatus = "failed" | "partial" | "success";

package/package.json

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

package/dist/dispatcherAgent/nodes/intentDispatcher.d.ts

@@ -1,2 +0,0 @@
-import { DispatcherGraphStateType } from '../state/dispatcherGraphState';
-export declare const intentDispatcher: (state: DispatcherGraphStateType) => DispatcherGraphStateType;

package/dist/intent_prompt-CRmsldou.js

@@ -1,22 +0,0 @@
-const e = `## GIS Feature Layer Intent Classifier
-
-You are an assistant that classifies user intent in ArcGIS Online Map Viewer.
-
-Return **up to {maxIntents} intents in the exact order they should be executed** for the user's request.
-If none apply, return an **empty list** (no "none" label).
-
-Choose only from registered agents. Input format will be: {{id: string, name: string, description: string}}[]
-{registeredAgents}
-
-Rules:
-
-- Pay primary attention to the **latest user query** when determining intents. Use the full context only if the latest query explicitly depends on it.
-- Output 0–{maxIntents} items, ordered for execution.
-- Do **not** include any labels outside the list above.
-- Do **not** include "none"; return an empty list instead when unrelated questions like labels, popups, etc.
-- If none apply, return an empty array [].
-- Each returned intent must be supported by evidence in the user request. Don’t add ‘nice-to-have’ follow-up intents.
-`;
-export {
-  e as default
-};