@arcgis/ai-orchestrator 5.1.0-next.93 → 5.1.0-next.95

package/dist/dispatcherAgent/reducers/commonReducers.d.ts

@@ -1,2 +1,3 @@
 export declare const replaceReducer: <T>(_prev: T, next: T) => T;
 export declare const mergeReducer: <T extends object>(prev: T, next: Partial<T>) => T;
+export declare const accumulateOutputMessageReducer: (current: string | undefined, update: unknown) => string;

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

@@ -1,8 +1,11 @@
-import { AgentExecutionContext } from '../../types/types';
+import { AgentExecutionContextShape, SharedState } from '../../types/types';
+type WritableAgentExecutionContext<TState extends SharedState = SharedState> = AgentExecutionContextShape<TState>;
 export declare const DispatcherGraphState: import('@langchain/langgraph').AnnotationRoot<{
-    agentExecutionContext: import('@langchain/langgraph').BaseChannel<AgentExecutionContext, AgentExecutionContext | import('@langchain/langgraph').OverwriteValue<AgentExecutionContext>, unknown>;
+    agentExecutionContext: import('@langchain/langgraph').BaseChannel<WritableAgentExecutionContext<SharedState<Record<string, unknown>>>, WritableAgentExecutionContext<SharedState<Record<string, unknown>>> | import('@langchain/langgraph').OverwriteValue<WritableAgentExecutionContext<SharedState<Record<string, unknown>>>>, 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>;
+    finalOutputMessage: import('@langchain/langgraph').BaseChannel<string, string | import('@langchain/langgraph').OverwriteValue<string>, unknown>;
 }>;
 export type DispatcherGraphStateType = typeof DispatcherGraphState.State;
+export {};

package/dist/index.d.ts

@@ -5,6 +5,7 @@ export { createChatModel } from './providers/arcgis/aiFactory';
 export { createWebmapEmbeddings } from './embeddings/webmapEmbeddings';
 export { getEmbeddings } from './embeddings/embeddingsUtil';
 export { cosineSimilarity } from './embeddings/cosineSimilarity';
+export { createAgentRuntimeState, createAgentRuntimeStateWithSharedState } from './utils/baseAgentState';
 export type { CustomConfigurableType, VectorSearchFieldResults, LayersAndFieldsRegistry, Services, FieldInfo, FieldStatistics, ChatHistory, AgentExecutionContext, AgentStatus, PriorStep, SharedState, SharedStatePatch, } from './types/types';
 export type { UXSuggestion } from './orchestrator/orchestratorEvents';
 export type { UiInterrupt } from './hitl/types';

package/dist/index.js

@@ -1,110 +1,150 @@
-import R from "@arcgis/core/identity/IdentityManager.js";
-import S from "@arcgis/core/portal/Portal.js";
-import { Annotation as x, isGraphInterrupt as ie, StateGraph as ae, START as oe, END as ce, MemorySaver as de } from "@langchain/langgraph/web";
-import { HumanMessage as N, AIMessage as A, isAIMessage as le, isToolMessage as ue } from "@langchain/core/messages";
-import { dispatchCustomEvent as O } from "@langchain/core/callbacks/dispatch/web";
-import h, { z as l } from "zod";
-import { ChatPromptTemplate as H, SystemMessagePromptTemplate as me } from "@langchain/core/prompts";
-import { createAgent as ge, summarizationMiddleware as pe, modelCallLimitMiddleware as he } from "langchain";
-import { ChatOpenAI as fe, OpenAIEmbeddings as ye } from "@langchain/openai";
-import * as V from "@arcgis/core/core/reactiveUtils.js";
-import z from "@arcgis/core/layers/FeatureLayer.js";
-import we from "@arcgis/core/request.js";
-const B = {
+import A from "@arcgis/core/identity/IdentityManager.js";
+import I from "@arcgis/core/portal/Portal.js";
+import { Annotation as h, isGraphInterrupt as oe, StateGraph as ce, START as de, END as le, MemorySaver as ue } from "@langchain/langgraph/web";
+import { HumanMessage as ge, AIMessage as W, isAIMessage as me, isToolMessage as pe } from "@langchain/core/messages";
+import { dispatchCustomEvent as N } from "@langchain/core/callbacks/dispatch/web";
+import f, { z as l } from "zod";
+import { ChatPromptTemplate as O, SystemMessagePromptTemplate as he } from "@langchain/core/prompts";
+import { createAgent as fe, summarizationMiddleware as ye, modelCallLimitMiddleware as we } from "langchain";
+import { ChatOpenAI as ve, OpenAIEmbeddings as xe } from "@langchain/openai";
+import * as H from "@arcgis/core/core/reactiveUtils.js";
+import V from "@arcgis/core/layers/FeatureLayer.js";
+import be from "@arcgis/core/request.js";
+const z = {
   advanced: "gpt-5.2",
   default: "gpt-5-mini",
   fast: "gpt-5.4-nano"
 }, C = {
   default: "text-embedding-ada-002"
-}, M = /* @__PURE__ */ new Map();
-let E = null;
-const ve = () => {
-  const t = S.getDefault().helperServices;
+}, k = /* @__PURE__ */ new Map();
+let S = null;
+const Ee = () => {
+  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 t.aiModels.url;
-}, G = async (e) => {
-  const t = ve();
-  M.size === 0 && (E || (E = (async () => {
+}, B = async (e) => {
+  const t = Ee();
+  k.size === 0 && (S || (S = (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((i) => M.set(i.name, i));
+      (await n.json()).models.forEach((a) => k.set(a.name, a));
     } catch (n) {
-      throw E = null, n;
+      throw S = null, n;
     }
-  })()), await E);
-  const r = M.get(e);
+  })()), await S);
+  const r = k.get(e);
   if (!r)
     throw new Error(`Model '${e}' is not available in the discovery service.`);
   return r.endpoint;
-}, xe = async (e = "default") => await G(B[e]), K = async (e = "default") => await G(C[e]), be = async (e) => {
-  const t = await Ee(), r = await K("default"), n = S.getDefault(), i = (await R.getCredential(`${n.url}/sharing`)).token, a = {
+}, Se = async (e = "default") => await B(z[e]), G = async (e = "default") => await B(C[e]), Ie = async (e) => {
+  const t = await Me(), r = await G("default"), n = I.getDefault(), a = (await A.getCredential(`${n.url}/sharing`)).token, i = {
     type: "generateEmbeddings",
     webmapEmbeddings: e,
-    auth: { apiUrl: r, token: i }
+    auth: { apiUrl: r, token: a }
   };
-  return t.postMessage(a), await new Promise((o, c) => {
-    const d = (m) => {
-      m.data === "completed" && (t.removeEventListener("message", d), o());
-    }, u = (m) => {
-      t.removeEventListener("message", d), c(m instanceof Error ? m : new Error("Embeddings worker error"));
+  return t.postMessage(i), await new Promise((o, c) => {
+    const d = (g) => {
+      g.data === "completed" && (t.removeEventListener("message", d), o());
+    }, u = (g) => {
+      t.removeEventListener("message", d), c(g instanceof Error ? g : new Error("Embeddings worker error"));
     };
     t.addEventListener("message", d), t.addEventListener("error", u, { once: !0 });
   }), t;
-}, Ee = async () => {
+}, Me = async () => {
   {
     const e = (await import("./embeddings.worker-GH7zdYqF.js")).default;
     return new e();
   }
-}, P = (e, t) => t, Se = (e, t) => ({
+}, b = (e, t) => t, K = (e, t) => ({
   ...e,
   ...t
-}), Ie = x.Root({
-  agentExecutionContext: x({
-    default: () => ({
-      userRequest: "",
-      assignedTask: "",
-      priorSteps: [],
-      messages: [],
-      sharedState: {}
-    }),
-    reducer: Se
+}), J = (e = "", t) => {
+  const r = typeof t == "string" ? t.trim() : "";
+  if (!r)
+    return e;
+  const n = e.trim();
+  if (!n)
+    return r;
+  if (n === r)
+    return e;
+  const s = n.split(`
+
+`);
+  return s[s.length - 1]?.trim() === r ? e : `${e}
+
+${r}`;
+}, X = () => ({
+  userRequest: "",
+  assignedTask: "",
+  messages: [],
+  priorSteps: [],
+  sharedState: {}
+}), ke = () => ({
+  agentExecutionContext: h({
+    reducer: K,
+    default: X
+  }),
+  outputMessage: h({
+    reducer: J,
+    default: () => ""
+  }),
+  summary: h({
+    reducer: b,
+    default: () => ""
   }),
-  currentIntent: x({
+  status: h({
+    reducer: b
+  })
+}), bt = () => ({
+  ...ke(),
+  sharedStatePatch: h({
+    reducer: b
+  })
+}), Re = h.Root({
+  agentExecutionContext: h({
+    default: X,
+    reducer: K
+  }),
+  currentIntent: h({
     default: () => "none",
-    reducer: P
+    reducer: b
   }),
-  requiresFollowUp: x({
+  requiresFollowUp: h({
     default: () => !0,
-    reducer: P
+    reducer: b
   }),
-  stepCount: x({
+  stepCount: h({
     default: () => 0,
     reducer: (e, t) => t ?? e + 1
+  }),
+  finalOutputMessage: h({
+    default: () => "",
+    reducer: J
   })
-}), f = async (e, t) => {
-  await O("trace_message", e, t);
-}, vt = async (e, t) => {
-  await O("graph_ux_suggestion", e, t);
-}, Me = (e) => {
+}), y = async (e, t) => {
+  await N("trace_message", e, t);
+}, Et = async (e, t) => {
+  await N("graph_ux_suggestion", e, t);
+}, Ae = (e) => {
   e.currentIntent = "none";
-}, ke = async (e, t) => {
+}, Ce = async (e, t) => {
   if (e.agentExecutionContext.userRequest) {
-    const n = new N(e.agentExecutionContext.userRequest.trim());
-    e.agentExecutionContext.messages = [...e.agentExecutionContext.messages, n], Me(e);
+    const n = new ge(e.agentExecutionContext.userRequest.trim());
+    e.agentExecutionContext.messages = [...e.agentExecutionContext.messages, n], Ae(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;
-}, Re = async (e, t) => (await f({ text: "Exiting..." }, t), e), L = (e) => typeof e == "object" && e !== null && !Array.isArray(e), Ae = (e, t) => {
-  if (!L(e)) {
+  return await y({ text: `Available agents: ${[...r].join(", ")}` }, t), await y({ text: "Analyzing user input" }, t), e;
+}, Te = async (e, t) => (await y({ text: "Exiting..." }, t), e), P = (e) => typeof e == "object" && e !== null && !Array.isArray(e), Fe = (e, t) => {
+  if (!P(e)) {
     e !== void 0 && console.warn(`Agent "${t}" returned invalid sharedStatePatch. Ignoring it.`);
     return;
   }
   const r = {};
   for (const [n, s] of Object.entries(e)) {
-    if (!L(s) || !("value" in s)) {
+    if (!P(s) || !("value" in s)) {
       console.warn(
         `Agent "${t}" returned invalid sharedStatePatch entry for key "${n}". Ignoring that entry.`
       );
@@ -113,28 +153,28 @@ const ve = () => {
     r[n] = { value: s.value };
   }
   return r;
-}, Ce = (e) => {
+}, De = (e) => {
   const { previousSharedState: t, patch: r, agentId: n } = e;
   if (!r)
     return t;
-  const s = Date.now(), i = {
+  const s = Date.now(), a = {
     ...t
   };
-  for (const [a, o] of Object.entries(r))
-    o.value !== void 0 && (i[a] = {
+  for (const [i, o] of Object.entries(r))
+    o?.value !== void 0 && (a[i] = {
       value: o.value,
       meta: {
         updatedByAgentId: n,
         updatedAt: s
       }
     });
-  return i;
-}, q = (e) => {
+  return a;
+}, L = (e) => {
   if (typeof e != "string")
     return;
   const t = e.trim();
   return t || void 0;
-}, Te = (e) => {
+}, $e = (e) => {
   switch (e) {
     case "failed":
       return "Agent failed without a summary.";
@@ -145,22 +185,22 @@ const ve = () => {
     default:
       return "Agent completed without a summary.";
   }
-}, Fe = (e, t) => {
-  const r = q(t?.outputMessage), n = q(t?.summary), s = t?.status, i = s === "success" || s === "failed" ? s : "unknown";
-  i === "unknown" && console.warn(`Agent "${e}" returned missing/invalid status. Defaulting to "unknown".`);
-  const a = Ae(t?.sharedStatePatch, e);
+}, Pe = (e, t) => {
+  const r = L(t?.outputMessage), n = L(t?.summary), s = t?.status, a = s === "success" || s === "failed" ? s : "unknown";
+  a === "unknown" && console.warn(`Agent "${e}" returned missing/invalid status. Defaulting to "unknown".`);
+  const i = Fe(t?.sharedStatePatch, e);
   return {
     outputMessage: r,
-    summary: n ?? r ?? Te(i),
-    status: i,
-    sharedStatePatch: a
+    summary: n ?? r ?? $e(a),
+    status: a,
+    sharedStatePatch: i
   };
-}, j = 4e3, De = async (e, t) => {
+}, q = 4e3, Le = 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 i = {
+  await y({ text: `Executing registered agent: ${s.agent.name}` }, t);
+  const a = {
     ...t ?? {},
     configurable: {
       ...r ?? {},
@@ -168,7 +208,7 @@ const ve = () => {
       context: s.getContext ? await s.getContext() : void 0
     }
   };
-  let a;
+  let i;
   try {
     const d = await s.agent.createGraph().compile().invoke(
       {
@@ -181,29 +221,30 @@ const ve = () => {
           sharedState: structuredClone(e.agentExecutionContext.sharedState ?? {})
         }
       },
-      i
+      a
     );
-    a = Fe(s.agent.name, d), await f({ text: `Finished executing registered agent: ${s.agent.name}` }, t);
+    i = Pe(s.agent.name, d), await y({ text: `Finished executing registered agent: ${s.agent.name}` }, t);
   } catch (d) {
-    if (ie(d))
+    if (oe(d))
       throw d;
     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), a = {
+    console.error(`Agent "${s.agent.name}" failed:`, d), await y({ text: `Registered agent failed: ${s.agent.name}. ${u}` }, t), i = {
       status: "failed",
       outputMessage: `Agent execution failed: ${u}`,
       summary: `Agent execution failed: ${u}`
     };
   }
-  const o = a.outputMessage, c = [...e.agentExecutionContext.messages];
+  const o = i.outputMessage, c = [...e.agentExecutionContext.messages];
   if (o) {
-    const d = o.length > j ? `${o.slice(0, j - 14)}
+    const d = o.length > q ? `${o.slice(0, q - 14)}
 [truncated]` : o;
-    c.push(new A(d));
+    c.push(new W(d));
   }
   return {
     ...e,
     stepCount: e.stepCount + 1,
-    requiresFollowUp: a.status === "failed" ? !0 : e.requiresFollowUp,
+    requiresFollowUp: i.status === "failed" ? !0 : e.requiresFollowUp,
+    finalOutputMessage: o ?? "",
     agentExecutionContext: {
       ...e.agentExecutionContext,
       messages: c,
@@ -212,23 +253,23 @@ const ve = () => {
         {
           agentId: s.agent.id,
           assignedTask: e.agentExecutionContext.assignedTask,
-          summary: a?.summary || "No summary provided.",
-          status: a?.status || "unknown"
+          summary: i?.summary || "No summary provided.",
+          status: i?.status || "unknown"
         }
       ],
-      sharedState: Ce({
+      sharedState: De({
         previousSharedState: e.agentExecutionContext.sharedState,
-        patch: a.sharedStatePatch,
+        patch: i.sharedStatePatch,
         agentId: s.agent.id
       })
     }
   };
-}, $e = (e, t, r) => {
+}, qe = (e, t, r) => {
   const n = e[t];
-  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." : ""))));
+  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." : ""))));
   });
-}, T = async (e) => (await $e(/* @__PURE__ */ Object.assign({ "./field_descriptions_prompt.md": () => import("./field_descriptions_prompt-haMV_aoG.js"), "./intent_prompt.md": () => import("./intent_prompt-D6yvMy34.js"), "./layer_descriptions_prompt.md": () => import("./layer_descriptions_prompt-NAaKWdJi.js") }), `./${e}.md`, 2)).default, Pe = async (e) => {
+}, T = async (e) => (await qe(/* @__PURE__ */ Object.assign({ "./field_descriptions_prompt.md": () => import("./field_descriptions_prompt-haMV_aoG.js"), "./intent_prompt.md": () => import("./intent_prompt-D6yvMy34.js"), "./layer_descriptions_prompt.md": () => import("./layer_descriptions_prompt-NAaKWdJi.js") }), `./${e}.md`, 2)).default, Ue = async (e) => {
   const { agent: t, messages: r, config: n } = e;
   return { structuredResponse: (await t.invoke(
     {
@@ -236,65 +277,65 @@ const ve = () => {
     },
     n
   )).structuredResponse };
-}, J = (e) => async (t, r) => {
+}, Q = (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
   });
-}, b = async (e = "default", t = 0) => {
-  const r = S.getDefault(), n = await R.getCredential(`${r.url}/sharing`), s = B[e], i = await xe(e);
-  return new fe({
+}, E = async (e = "default", t = 0) => {
+  const r = I.getDefault(), n = await A.getCredential(`${r.url}/sharing`), s = z[e], a = await Se(e);
+  return new ve({
     modelName: s,
     apiKey: "dummy-key",
     // 5-mini does not support temperature parameter
     ...e !== "default" && { temperature: t },
     configuration: {
-      baseURL: i,
-      fetch: J(n.token)
+      baseURL: a,
+      fetch: Q(n.token)
     }
   });
-}, Le = async (e = "default") => {
-  const t = S.getDefault(), r = await R.getCredential(`${t.url}/sharing`), n = C[e], s = await K(e);
-  return new ye({
+}, je = async (e = "default") => {
+  const t = I.getDefault(), r = await A.getCredential(`${t.url}/sharing`), n = C[e], s = await G(e);
+  return new xe({
     modelName: n,
     apiKey: "dummy-key",
     configuration: {
       baseURL: s,
-      fetch: J(r.token)
+      fetch: Q(r.token)
     },
     batchSize: 2048,
     maxConcurrency: 10
   });
-}, qe = l.object({
+}, _e = l.object({
   id: l.string().min(1),
   name: l.string().min(1),
   description: l.string().min(1)
 });
-l.array(qe);
-const U = (e) => JSON.stringify(e, null, 2), je = (e) => {
+l.array(_e);
+const U = (e) => JSON.stringify(e, null, 2), We = (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()
   });
-}, Ue = async (e, t) => {
+}, Ne = async (e, t) => {
   try {
-    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
+    await y({ text: "Asking LLM to route to an agent" }, t);
+    const s = (t?.configurable?.services.agentRegistry?.list() ?? []).map(({ agent: x }) => ({
+      id: x.id,
+      name: x.name,
+      description: x.description
     }));
     if (!s.length)
-      return await f({ text: "No agents registered; skipping intent detection" }, t), { ...e, currentIntent: "none" };
-    const i = await T("intent_prompt"), a = U(s), o = je(s), c = {
-      registeredAgents: a,
+      return await y({ text: "No agents registered; skipping intent detection" }, t), { ...e, currentIntent: "none" };
+    const a = await T("intent_prompt"), i = U(s), o = We(s), c = {
+      registeredAgents: i,
       priorSteps: U(e.agentExecutionContext.priorSteps),
       userRequest: e.agentExecutionContext.userRequest
-    }, u = await H.fromTemplate(i).format(c), m = ge({
-      model: await b("fast"),
+    }, u = await O.fromTemplate(a).format(c), g = fe({
+      model: await E("fast"),
       tools: [],
       systemPrompt: u,
       checkpointer: !0,
@@ -303,40 +344,40 @@ const U = (e) => JSON.stringify(e, null, 2), je = (e) => {
         // 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.
-        pe({
-          model: await b("fast"),
+        ye({
+          model: await E("fast"),
           trigger: { tokens: 4e3 },
           keep: { messages: 6 }
         }),
         // Enforce no loop/retry.
         // 1 usual LLM call and 1 optional summarization call.
-        he({ runLimit: 2 })
+        we({ runLimit: 2 })
       ]
-    }), { structuredResponse: y } = await Pe({
-      agent: m,
+    }), { structuredResponse: w } = await Ue({
+      agent: g,
       messages: e.agentExecutionContext.messages,
       config: t
     }), p = o.parse(
-      y ?? { intent: null, assignedTask: null, requiresFollowUp: !1 }
-    ), g = p.intent ?? "none", I = {
+      w ?? { intent: null, assignedTask: null, requiresFollowUp: !1 }
+    ), m = p.intent ?? "none", M = {
       ...e,
-      currentIntent: g,
+      currentIntent: m,
       requiresFollowUp: p.requiresFollowUp,
       agentExecutionContext: {
         ...e.agentExecutionContext,
         assignedTask: p.assignedTask ?? ""
       }
     };
-    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), {
+    if (m === "none") {
+      const x = "I could not find a matching agent for that request. Please rephrase your question with more detail.";
+      return await y({ text: "LLM did not identify a clear intent." }, t), {
         ...e,
-        currentIntent: g,
+        currentIntent: m,
         requiresFollowUp: !1,
         agentExecutionContext: {
           ...e.agentExecutionContext,
           assignedTask: "",
-          messages: [...e.agentExecutionContext.messages, new A(v)],
+          messages: [...e.agentExecutionContext.messages, new W(x)],
           priorSteps: [
             ...e.agentExecutionContext.priorSteps ?? [],
             {
@@ -349,22 +390,22 @@ const U = (e) => JSON.stringify(e, null, 2), je = (e) => {
         }
       };
     }
-    return await f(
+    return await y(
       {
-        text: `Agent picked: ${g}
+        text: `Agent picked: ${m}
 Task Assigned: ${p.assignedTask ?? ""}
 Requires Follow-Up: ${p.requiresFollowUp}`
       },
       t
-    ), I;
+    ), M;
   } 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 y({ text: "Error during intent detection" }, t), new Error(`Error during intent detection: ${r instanceof Error ? r.message : String(r)}`);
   }
-}, _e = 3, We = () => new ae(Ie).addNode("ingestInput", ke).addNode("intentLLM", Ue).addNode("executeRegisteredAgent", De).addNode("exit", Re).addEdge(oe, "ingestInput").addEdge("ingestInput", "intentLLM").addConditionalEdges("intentLLM", (t) => t.currentIntent === "none" ? "exit" : "executeRegisteredAgent").addConditionalEdges(
+}, Oe = 3, He = () => new ce(Re).addNode("ingestInput", Ce).addNode("intentLLM", Ne).addNode("executeRegisteredAgent", Le).addNode("exit", Te).addEdge(de, "ingestInput").addEdge("ingestInput", "intentLLM").addConditionalEdges("intentLLM", (t) => t.currentIntent === "none" ? "exit" : "executeRegisteredAgent").addConditionalEdges(
   "executeRegisteredAgent",
-  (t) => t.stepCount >= _e || !t.requiresFollowUp ? "exit" : "intentLLM"
-).addEdge("exit", ce);
-class Ne {
+  (t) => t.stepCount >= Oe || !t.requiresFollowUp ? "exit" : "intentLLM"
+).addEdge("exit", le);
+class Ve {
   constructor() {
     this.agentRegistry = /* @__PURE__ */ new Map();
   }
@@ -381,7 +422,7 @@ class Ne {
     return [...this.agentRegistry.values()];
   }
 }
-class Oe {
+class ze {
   /**
    * Create a new InterruptHandler tied to a specific compiled graph and config.
    */
@@ -428,32 +469,23 @@ class Oe {
     this.rejectWait && (this.rejectWait(new Error("Request cancelled by user.")), this.resolveWait = void 0, this.rejectWait = void 0);
   }
 }
-const He = (e) => {
-  let t = -1;
-  for (let r = e.length - 1; r >= 0; r--)
-    if (e[r] instanceof N) {
-      t = r;
-      break;
-    }
-  return t === -1 ? "" : e.slice(t + 1).filter((r) => r instanceof A).map((r) => r.content).join(`
-`);
-}, X = async (e) => {
+const Y = async (e) => {
   try {
-    return await (await Le()).embedDocuments(e);
+    return await (await je()).embedDocuments(e);
   } catch (t) {
     throw console.error("Failed to generate embeddings:", t), t;
   }
-}, Q = async (e, t) => {
+}, Z = async (e, t) => {
   const r = t.get(e);
   if (r)
     return r;
-  const n = await X([e]);
+  const n = await Y([e]);
   return t.set(e, n[0]), n[0];
 };
-async function Ve(e, t, r, n) {
-  const s = `req-${Date.now()}`, a = {
+async function Be(e, t, r, n) {
+  const s = `req-${Date.now()}`, i = {
     type: "layerSearch",
-    precomputedEmbedding: n ? await Q(e, n) : void 0,
+    precomputedEmbedding: n ? await Z(e, n) : void 0,
     requestId: s,
     minScore: r
   };
@@ -461,10 +493,10 @@ async function Ve(e, t, r, n) {
     const c = (d) => {
       d.data.requestId === s && o(d.data.results);
     };
-    t.addEventListener("message", c, { once: !0 }), t.postMessage(a);
+    t.addEventListener("message", c, { once: !0 }), t.postMessage(i);
   });
 }
-function ze(e) {
+function Ge(e) {
   const { worker: t } = e;
   return {
     async searchLayers({
@@ -472,65 +504,65 @@ function ze(e) {
       minScore: n,
       embeddingCache: s
     }) {
-      return await Ve(r, t, n, s);
+      return await Be(r, t, n, s);
     }
   };
 }
-const Be = async ({
+const Ke = async ({
   combinedQuery: e,
   layerIds: t,
   embeddingsWorker: r,
   minScore: n,
   topResults: s,
-  embeddingCache: i
+  embeddingCache: a
 }) => {
-  const a = `req-${Date.now()}`, o = i ? await Q(e, i) : void 0, c = {
+  const i = `req-${Date.now()}`, o = a ? await Z(e, a) : void 0, c = {
     type: "fieldSearch",
     layerIdForFieldsSearch: t,
     precomputedEmbedding: o,
-    requestId: a,
+    requestId: i,
     minScore: n,
     topResults: s
   };
   return await new Promise((d) => {
-    const u = (m) => {
-      if (m.data.requestId !== a)
+    const u = (g) => {
+      if (g.data.requestId !== i)
         return;
-      const y = m.data.results.map(({ layerId: p, results: g }) => ({
+      const w = g.data.results.map(({ layerId: p, results: m }) => ({
         layerId: p,
-        results: g
+        results: m
       }));
-      d(y);
+      d(w);
     };
     r.addEventListener("message", u, { once: !0 }), r.postMessage(c);
   });
 };
-function Ge(e) {
+function Je(e) {
   const { worker: t } = e;
   return {
-    async searchFields({ text: r, layerIds: n, minScore: s, topResults: i, embeddingCache: a }) {
-      return await Be({
+    async searchFields({ text: r, layerIds: n, minScore: s, topResults: a, embeddingCache: i }) {
+      return await Ke({
         combinedQuery: r,
         layerIds: n,
         embeddingsWorker: t,
         minScore: s,
-        topResults: i,
-        embeddingCache: a
+        topResults: a,
+        embeddingCache: i
       });
     }
   };
 }
-const Y = "0.1", w = 1536, Z = "openai", ee = C.default, F = `Name: {name}
+const ee = "0.1", v = 1536, te = "openai", ne = C.default, F = `Name: {name}
 Title: {title}
 Description: {description}`, D = `Name: {name}
 Alias: {alias}
-Description: {description}`, te = l.object({
-  schemaVersion: l.literal(Y),
+Description: {description}`, re = l.object({
+  schemaVersion: l.literal(ee),
   modified: l.number().int().nonnegative(),
   embeddings: l.object({
-    modelProvider: l.literal(Z),
-    model: l.literal(ee),
-    dimensions: l.literal(w),
+    modelProvider: l.literal(te),
+    model: l.literal(ne),
+    dimensions: l.literal(v),
     templates: l.object({
       layer: l.string().default(F),
       field: l.string().default(D)
@@ -542,89 +574,89 @@ Description: {description}`, te = l.object({
       name: l.string().min(1),
       title: l.string().catch(""),
       description: l.string().catch(""),
-      vector: l.array(l.number()).length(w, {
-        message: `Layer vector must be exactly ${w} dimensions`
+      vector: l.array(l.number()).length(v, {
+        message: `Layer vector must be exactly ${v} dimensions`
       }),
       fields: l.array(
         l.object({
           name: l.string().min(1),
           alias: l.string().catch(""),
           description: l.string().catch(""),
-          vector: l.array(l.number()).length(w, {
-            message: `Field vector must be exactly ${w} dimensions`
+          vector: l.array(l.number()).length(v, {
+            message: `Field vector must be exactly ${v} dimensions`
           })
         })
       )
     })
   ).default([])
-}), Ke = (e) => {
-  const t = te.safeParse(e);
+}), Xe = (e) => {
+  const t = re.safeParse(e);
   if (!t.success)
     throw new Error("Embeddings response validation failed. Regenerate embeddings.");
   return t.data;
-}, Je = (e, t) => {
+}, Qe = (e, t) => {
   const r = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map();
   if (t.allLayers.forEach((s) => {
-    s instanceof z && n.set(s.id, s);
+    s instanceof V && 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 i = n.get(s.id);
-    if (!i)
+    const a = n.get(s.id);
+    if (!a)
       throw new Error(
         `Layer with ID ${s.id} not found in the original map during registry restoration. Regenerate embeddings.`
       );
-    if (s.fields.length !== i.fields.length)
+    if (s.fields.length !== a.fields.length)
       throw new Error(
         `Field count mismatch for layer ID ${s.id} during registry restoration. Regenerate embeddings.`
       );
-    const a = {
+    const i = {
       name: s.name,
       title: s.title,
       description: s.description
     }, o = /* @__PURE__ */ new Map();
     for (const c of s.fields) {
-      const d = i.fieldsIndex.get(c.name);
+      const d = a.fieldsIndex.get(c.name);
       if (!d)
         throw new Error(
           `Field with name ${c.name} not found in the original layer ${s.id} during registry restoration. Regenerate embeddings.`
         );
       o.set(c.name, {
         name: c.name,
-        alias: i.getFieldAlias(c.name) ?? c.alias,
+        alias: a.getFieldAlias(c.name) ?? c.alias,
         description: c.description,
         type: d.type || "unknown",
         valueType: d.valueType || "unknown",
-        domain: i.getFieldDomain(c.name) ?? void 0
+        domain: a.getFieldDomain(c.name) ?? void 0
       });
     }
     r.set(s.id, {
-      layerItem: a,
+      layerItem: i,
       fieldRegistry: o
     });
   }
   return r;
-}, Xe = async (e) => {
+}, Ye = async (e) => {
   try {
-    return (await we(e, {
+    return (await be(e, {
       responseType: "json"
     })).data;
   } catch (t) {
     throw new Error(`Failed to fetch data from ${e}: ${String(t)}`);
   }
-}, Qe = async (e) => {
+}, Ze = 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((a) => a.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 Xe(n.resource.url);
-  return Ke(s);
+  const s = await Ye(n.resource.url);
+  return Xe(s);
 };
-class ne {
+class se {
   constructor() {
-    this.orchestratorReady = !1, this.chatHistory = [], this.priorSteps = [], this.sharedState = {}, this.threadId = "", this.agentRegistry = new Ne(), this.streamEpoch = 0;
+    this.orchestratorReady = !1, this.chatHistory = [], this.priorSteps = [], this.sharedState = {}, this.threadId = "", this.agentRegistry = new Ve(), this.streamEpoch = 0;
   }
   /**
    * Creates and returns an AI-ready Orchestrator instance.
@@ -632,15 +664,15 @@ class ne {
    * @returns Ready Orchestrator.
    */
   static async init(t) {
-    const r = new ne();
+    const r = new se();
     try {
       if (t.view?.map) {
-        await V.whenOnce(() => t.view.ready);
-        const n = await Qe(t.view), s = Je(
+        await H.whenOnce(() => t.view.ready);
+        const n = await Ze(t.view), s = Qe(
           n.layers,
           t.view.map
         );
-        r.layersAndFieldsRegistry = s, r.embeddingsWorker = await be(n);
+        r.layersAndFieldsRegistry = s, r.embeddingsWorker = await Ie(n);
       }
       return t.agents?.forEach((n) => {
         r.agentRegistry.register(n);
@@ -664,8 +696,8 @@ class ne {
       throw new Error("Orchestrator has no registered agents.");
     if (++this.streamEpoch, !t.trim())
       return;
-    this.threadId = String(Date.now()), this.graph || (this.graph = We().compile({ checkpointer: new de() }));
-    const r = this.embeddingsWorker ? ze({ worker: this.embeddingsWorker }) : void 0, n = this.embeddingsWorker ? Ge({ worker: this.embeddingsWorker }) : void 0, s = /* @__PURE__ */ new Map(), a = {
+    this.threadId = String(Date.now()), this.graph || (this.graph = He().compile({ checkpointer: new ue() }));
+    const r = this.embeddingsWorker ? Ge({ worker: this.embeddingsWorker }) : void 0, n = this.embeddingsWorker ? Je({ worker: this.embeddingsWorker }) : void 0, s = /* @__PURE__ */ new Map(), i = {
       version: "v2",
       streamMode: "custom",
       configurable: {
@@ -690,23 +722,23 @@ class ne {
           sharedState: this.sharedState
         }
       },
-      a
+      i
     ), c = ++this.streamEpoch;
     for (yield* this.pipeStream(o, c); ; ) {
-      const p = (await this.graph.getState(a, { subgraphs: !0 })).tasks.find((g) => g.interrupts.length > 0)?.interrupts[0]?.value;
+      const p = (await this.graph.getState(i, { subgraphs: !0 })).tasks.find((m) => m.interrupts.length > 0)?.interrupts[0]?.value;
       if (!p)
         break;
-      this.currentInterrupt = p, this.interruptHandler = new Oe(this.graph, a), yield { runId: this.threadId, timestamp: Date.now(), type: "interrupt", interrupt: p };
+      this.currentInterrupt = p, this.interruptHandler = new ze(this.graph, i), yield { runId: this.threadId, timestamp: Date.now(), type: "interrupt", interrupt: p };
       try {
-        const g = await this.interruptHandler.waitForUser(), I = ++this.streamEpoch;
-        yield* this.pipeStream(g, I);
-      } catch (g) {
-        if (g) {
+        const m = await this.interruptHandler.waitForUser(), M = ++this.streamEpoch;
+        yield* this.pipeStream(m, M);
+      } catch (m) {
+        if (m) {
           yield {
             runId: this.threadId,
             timestamp: Date.now(),
             type: "error",
-            error: { message: g?.message }
+            error: { message: m?.message }
           };
           return;
         }
@@ -714,12 +746,12 @@ class ne {
         return;
       }
     }
-    const u = (await this.graph.getState(a, { subgraphs: !0 })).values;
+    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) ?? [], this.sharedState = u.agentExecutionContext.sharedState ?? {}, yield {
       runId: this.threadId,
       timestamp: Date.now(),
       type: "completed",
-      result: { content: He(u.agentExecutionContext.messages) }
+      result: { content: u.finalOutputMessage }
     };
   }
   /**
@@ -765,63 +797,63 @@ class ne {
     this.embeddingsWorker && (this.embeddingsWorker.terminate(), this.embeddingsWorker = void 0), this.orchestratorReady = !1;
   }
 }
-const Ye = (e) => {
+const et = (e) => {
   const t = /* @__PURE__ */ new Set();
   for (const n of e)
-    if (le(n)) {
+    if (me(n)) {
       const s = n;
-      s.tool_calls && s.tool_calls.length > 0 && s.tool_calls.forEach((i) => {
-        i.id && t.add(i.id);
+      s.tool_calls && s.tool_calls.length > 0 && s.tool_calls.forEach((a) => {
+        a.id && t.add(a.id);
       });
     }
   return e.filter((n) => {
-    if (ue(n)) {
+    if (pe(n)) {
       const s = n;
       return t.has(s.tool_call_id);
     }
     return !0;
   });
 }, $ = (e, t) => {
-  const r = me.fromTemplate(e);
-  return H.fromMessages([r, ...t]);
-}, Ze = async (e) => {
-  const { promptText: t, modelTier: r, temperature: n, messages: s } = e, i = $(t, s ?? []), a = await b(r, n);
-  return i.pipe(a);
-}, xt = async (e) => {
-  const { promptText: t, modelTier: r = "default", temperature: n = 0, messages: s, inputVariables: i } = e, o = await (await Ze({
+  const r = he.fromTemplate(e);
+  return O.fromMessages([r, ...t]);
+}, tt = async (e) => {
+  const { promptText: t, modelTier: r, temperature: n, messages: s } = e, a = $(t, s ?? []), i = await E(r, n);
+  return a.pipe(i);
+}, St = async (e) => {
+  const { promptText: t, modelTier: r = "default", temperature: n = 0, messages: s, inputVariables: a } = e, o = await (await tt({
     promptText: t,
     modelTier: r,
     temperature: n,
     messages: s
-  })).invoke(i ?? {});
+  })).invoke(a ?? {});
   if (typeof o == "string")
     return o;
   const c = o.content;
   return typeof c == "string" ? c : JSON.stringify(c);
-}, re = async (e) => {
-  const { promptText: t, modelTier: r = "default", temperature: n = 0, messages: s, inputVariables: i, schema: a } = e, o = $(t, s ?? []), d = (await b(r, n)).withStructuredOutput(a);
-  return await o.pipe(d).invoke(i ?? {});
-}, bt = async (e) => {
-  const { promptText: t, modelTier: r = "default", temperature: n = 0, messages: s, inputVariables: i, tools: a } = e, o = a.length > 0 ? Ye(s ?? []) : s ?? [], c = $(t, o), d = await b(r, n);
-  return await c.pipe(d.bindTools(a)).invoke(i ?? {});
-}, et = h.object({
-  name: h.string(),
-  description: h.string(),
-  valueType: h.string(),
-  alias: h.string()
-}), tt = h.object({
-  fields: h.array(et)
-}), se = (e, t) => e.getFieldAlias(t) ?? void 0, k = (e, t) => se(e, t.name) ?? t.alias ?? "", nt = (e, t) => {
-  const r = se(e, t.name);
+}, ae = async (e) => {
+  const { promptText: t, modelTier: r = "default", temperature: n = 0, messages: s, inputVariables: a, schema: i } = e, o = $(t, s ?? []), d = (await E(r, n)).withStructuredOutput(i);
+  return await o.pipe(d).invoke(a ?? {});
+}, It = async (e) => {
+  const { promptText: t, modelTier: r = "default", temperature: n = 0, messages: s, inputVariables: a, tools: i } = e, o = i.length > 0 ? et(s ?? []) : s ?? [], c = $(t, o), d = await E(r, n);
+  return await c.pipe(d.bindTools(i)).invoke(a ?? {});
+}, nt = f.object({
+  name: f.string(),
+  description: f.string(),
+  valueType: f.string(),
+  alias: f.string()
+}), rt = f.object({
+  fields: f.array(nt)
+}), ie = (e, t) => e.getFieldAlias(t) ?? void 0, R = (e, t) => ie(e, t.name) ?? t.alias ?? "", st = (e, t) => {
+  const r = ie(e, t.name);
   return !!(r && r !== (t.alias ?? ""));
 };
-function _(e, t) {
+function j(e, t) {
   const r = /* @__PURE__ */ new Map();
   for (const n of e.fields) {
-    const s = t.fields.find((c) => c.name === n.name), i = k(e, n), a = nt(e, n), o = {
+    const s = t.fields.find((c) => c.name === n.name), a = R(e, n), i = st(e, n), o = {
       name: n.name,
       type: n.type,
-      alias: a ? i : s?.alias ?? i,
+      alias: i ? a : s?.alias ?? a,
       description: s?.description ?? n.description ?? "",
       valueType: s?.valueType ?? n.valueType ?? "",
       domain: e.getFieldDomain(n.name) ?? void 0
@@ -830,111 +862,111 @@ function _(e, t) {
   }
   return r;
 }
-const rt = async (e) => {
-  const r = await T("field_descriptions_prompt"), n = e.fields.filter((a) => !(k(e, a) && a.description)).map((a) => {
-    const { name: o, type: c, description: d } = a, u = k(e, a);
+const at = async (e) => {
+  const r = await T("field_descriptions_prompt"), n = e.fields.filter((i) => !(R(e, i) && i.description)).map((i) => {
+    const { name: o, type: c, description: d } = i, u = R(e, i);
     return [`Name: ${o}`, `Type: ${c}`, `Alias: ${u}`, `Description: ${d ?? "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
-  }, i = await re({
+  }, a = await ae({
     promptText: r,
-    schema: tt,
+    schema: rt,
     inputVariables: s
   });
-  return _(e, i);
-}, st = h.object({
-  title: h.string(),
-  description: h.string(),
-  name: h.string().nullable()
-}), it = async (e, t) => {
-  const n = await T("layer_descriptions_prompt"), s = Array.from(t.values()), i = {
+  return j(e, a);
+}, it = f.object({
+  title: f.string(),
+  description: f.string(),
+  name: f.string().nullable()
+}), ot = async (e, t) => {
+  const n = await T("layer_descriptions_prompt"), s = Array.from(t.values()), a = {
     fieldInformation: JSON.stringify(s, null, 2),
     existingLayerTitle: e.title,
     existingLayerDescription: e.portalItem?.description,
     existingLayerSnippet: e.portalItem?.snippet,
     layerGeometryType: e.geometryType
   };
-  return { ...await re({
+  return { ...await ae({
     promptText: n,
-    schema: st,
-    inputVariables: i
+    schema: it,
+    inputVariables: a
   }), name: e.title ?? null };
-}, at = async (e) => {
+}, ct = async (e) => {
   const t = e.allLayers.toArray(), r = [], n = /* @__PURE__ */ new Map();
   for (const s of t)
-    if (s instanceof z) {
-      const i = (async () => {
-        const a = await rt(s), o = await it(s, a);
-        n.set(s.id, { layerItem: o, fieldRegistry: a });
+    if (s instanceof V) {
+      const a = (async () => {
+        const i = await at(s), o = await ot(s, i);
+        n.set(s.id, { layerItem: o, fieldRegistry: i });
       })();
-      r.push(i);
+      r.push(a);
     }
   return await Promise.all(r), n;
-}, Et = async (e) => {
-  await V.whenOnce(() => e.ready);
-  const t = await at(e.map), { layers: r } = await ot(t), n = {
-    schemaVersion: Y,
+}, Mt = async (e) => {
+  await H.whenOnce(() => e.ready);
+  const t = await ct(e.map), { layers: r } = await dt(t), n = {
+    schemaVersion: ee,
     modified: Date.now(),
     embeddings: {
-      modelProvider: Z,
-      model: ee,
-      dimensions: w,
+      modelProvider: te,
+      model: ne,
+      dimensions: v,
       templates: {
         layer: F,
         field: D
       }
     },
     layers: r
-  }, s = te.safeParse(n);
+  }, s = re.safeParse(n);
   if (!s.success)
     throw console.error("Schema Mismatch:", s.error.format()), new Error("Webmap embedding generation failed validation.");
   return s.data;
-}, ot = async (e) => {
+}, dt = async (e) => {
   const t = [], r = [];
-  for (const [a, { fieldRegistry: o, layerItem: c }] of e.entries()) {
-    const d = W(F, {
+  for (const [i, { fieldRegistry: o, layerItem: c }] of e.entries()) {
+    const d = _(F, {
       name: c.name,
       title: c.title,
       description: c.description
     });
     t.push(d);
     const u = {
-      id: a,
+      id: i,
       name: c.name ?? "",
       title: c.title,
       description: c.description,
       vector: [],
       fields: []
     };
-    for (const [, m] of o.entries()) {
-      const y = W(D, {
-        name: m.name,
-        alias: m.alias,
-        description: m.description
+    for (const [, g] of o.entries()) {
+      const w = _(D, {
+        name: g.name,
+        alias: g.alias,
+        description: g.description
       });
-      t.push(y), u.fields.push({
-        name: m.name,
-        alias: m.alias,
-        description: m.description,
+      t.push(w), u.fields.push({
+        name: g.name,
+        alias: g.alias,
+        description: g.description,
         vector: []
       });
     }
     r.push(u);
   }
-  const n = await X(t);
+  const n = await Y(t);
   let s = 0;
-  return { layers: r.map((a) => (a.vector = n[s++], a.fields.forEach((o) => {
+  return { layers: r.map((i) => (i.vector = n[s++], i.fields.forEach((o) => {
     o.vector = n[s++];
-  }), a)) };
-}, W = (e, t) => e.replace(/\{(\w+)\}/gu, (r, n) => t[n] ?? ""), St = (e, t) => {
+  }), i)) };
+}, _ = (e, t) => e.replace(/\{(\w+)\}/gu, (r, n) => t[n] ?? ""), kt = (e, t) => {
   if (e.length !== t.length)
     throw new Error("Vectors must be the same length");
   let r = 0, n = 0, s = 0;
@@ -942,21 +974,23 @@ const rt = async (e) => {
     const c = e[o], d = t[o];
     r += c * d, n += c * c, s += d * d;
   }
-  const i = Math.sqrt(n * s);
-  if (i === 0)
+  const a = Math.sqrt(n * s);
+  if (a === 0)
     return 0;
-  const a = r / i;
-  return Math.max(-1, Math.min(1, a));
+  const i = r / a;
+  return Math.max(-1, Math.min(1, i));
 };
 export {
-  ne as Orchestrator,
-  St as cosineSimilarity,
-  b as createChatModel,
-  Et as createWebmapEmbeddings,
-  X as getEmbeddings,
-  re as invokeStructuredPrompt,
-  xt as invokeTextPrompt,
-  bt as invokeToolPrompt,
-  f as sendTraceMessage,
-  vt as sendUXSuggestion
+  se as Orchestrator,
+  kt as cosineSimilarity,
+  ke as createAgentRuntimeState,
+  bt as createAgentRuntimeStateWithSharedState,
+  E as createChatModel,
+  Mt as createWebmapEmbeddings,
+  Y as getEmbeddings,
+  ae as invokeStructuredPrompt,
+  St as invokeTextPrompt,
+  It as invokeToolPrompt,
+  y as sendTraceMessage,
+  Et as sendUXSuggestion
 };

package/dist/types/types.d.ts

@@ -58,36 +58,43 @@ export type CustomConfigurableType = Record<string, unknown> & {
 };
 /** Cache for query embeddings to avoid duplicate API calls within a request */
 export type QueryEmbeddingCache = Map<string, number[]>;
-type SharedStateEntry = {
-    value: unknown;
+/** Stored shared state entry. `meta` is added by the orchestrator. */
+type SharedStateEntry<T = unknown> = {
+    value: T;
     meta: {
         updatedByAgentId: string;
         updatedAt: number;
     };
 };
+/** Patch shape returned by agents. `meta` is intentionally omitted. */
 type SharedStatePatchEntry<T = unknown> = {
     value: T;
 };
-export type SharedState = Record<string, SharedStateEntry>;
-export type SharedStatePatch = Record<string, SharedStatePatchEntry>;
-export interface AgentExecutionContext {
+export type SharedState<T extends Record<string, unknown> = Record<string, unknown>> = {
+    [K in keyof T]?: SharedStateEntry<T[K]>;
+};
+export type SharedStatePatch<T extends Record<string, unknown> = Record<string, unknown>> = {
+    [K in keyof T]?: SharedStatePatchEntry<T[K]>;
+};
+export type AgentExecutionContextShape<TState extends SharedState = SharedState> = {
     userRequest: string;
     assignedTask: string;
     messages: ChatHistory;
     priorSteps: PriorStep[];
-    sharedState: SharedState;
-}
+    sharedState: TState;
+};
+export type AgentExecutionContext<TState extends SharedState = SharedState> = Readonly<AgentExecutionContextShape<TState>>;
 export interface PriorStep {
     agentId: string;
     assignedTask: string;
     summary: string;
     status: AgentStatus;
 }
-export interface AgentResult {
+export interface AgentResult<TPatch extends SharedStatePatch = SharedStatePatch> {
     status?: AgentStatus;
     outputMessage?: string;
     summary?: string;
-    sharedStatePatch?: SharedStatePatch;
+    sharedStatePatch?: TPatch;
 }
 export type AgentStatus = "failed" | "success" | "unknown";
 export {};

package/dist/utils/baseAgentState.d.ts

@@ -0,0 +1,27 @@
+import { BaseChannel } from '@langchain/langgraph/web';
+import { AgentExecutionContext, AgentStatus, SharedStatePatch } from '../types/types';
+/**
+ * Base state channel definitions
+ */
+type StatelessAgentBaseState = {
+    agentExecutionContext: BaseChannel<AgentExecutionContext, unknown, unknown>;
+    outputMessage: BaseChannel<string, unknown, unknown>;
+    summary: BaseChannel<string, unknown, unknown>;
+    status: BaseChannel<AgentStatus | undefined, unknown, unknown>;
+};
+type StatefulAgentBaseState<TPatch extends SharedStatePatch = SharedStatePatch> = StatelessAgentBaseState & {
+    sharedStatePatch: BaseChannel<TPatch | undefined, unknown, unknown>;
+};
+/**
+ * Default context factory
+ */
+export declare const createDefaultAgentExecutionContext: () => AgentExecutionContext;
+/**
+ * Stateless base state (no shared state patch)
+ */
+export declare const createAgentRuntimeState: () => StatelessAgentBaseState;
+/**
+ * Stateful base state (includes shared state patch)
+ */
+export declare const createAgentRuntimeStateWithSharedState: <TPatch extends SharedStatePatch = SharedStatePatch>() => StatefulAgentBaseState<TPatch>;
+export {};

package/dist/utils/contextSelectors.d.ts

@@ -5,8 +5,3 @@ import { BaseMessage } from '@langchain/core/messages';
  * @knipIgnore
  */
 export declare const getUserContext: (messages: BaseMessage[], userCount?: number) => BaseMessage[];
-/**
- * Returns the concatenated content of all AI messages
- * that occur after the last HumanMessage.
- */
-export declare const finalAgentResponse: (messages: BaseMessage[]) => string;

package/package.json

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