@arcgis/ai-orchestrator 5.1.0-next.73 → 5.1.0-next.74

package/dist/index.js

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

package/dist/utils/invokeAgent.d.ts

@@ -0,0 +1,21 @@
+import { BaseMessage } from '@langchain/core/messages';
+import { RunnableConfig } from '@langchain/core/runnables';
+type AgentInvoker = {
+    invoke: (input: {
+        messages: BaseMessage[];
+    }, config?: RunnableConfig) => Promise<Record<string, unknown> | {
+        messages: BaseMessage[];
+    }>;
+};
+type InvokeAgentOptions = {
+    agent: AgentInvoker;
+    messages: BaseMessage[];
+    config?: RunnableConfig;
+};
+/**
+ * Invokes an agent with a runnable config and returns the latest AI text response.
+ */
+export declare const invokeAgent: (options: InvokeAgentOptions) => Promise<{
+    structuredResponse?: unknown;
+}>;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcgis/ai-orchestrator",
-  "version": "5.1.0-next.73",
+  "version": "5.1.0-next.74",
   "description": "ArcGIS AI Orchestrator Package",
   "homepage": "https://developers.arcgis.com/javascript/latest/",
   "type": "module",
@@ -16,9 +16,10 @@
   ],
   "license": "SEE LICENSE IN LICENSE.md",
   "dependencies": {
-    "@langchain/core": "^1.1.34",
-    "@langchain/langgraph": "^1.2.5",
-    "@langchain/openai": "^1.3.0",
+    "@langchain/core": "^1.1.39",
+    "@langchain/langgraph": "^1.2.6",
+    "@langchain/openai": "^1.4.3",
+    "langchain": "^1.3.1",
     "tslib": "^2.8.1",
     "zod": "^4.3.6"
   },