@arcgis/ai-components 5.2.0-next.99 → 6.0.0-next.1

package/dist/orchestrator/orchestrator/orchestrator.js

@@ -0,0 +1,977 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+import P from "@arcgis/core/identity/IdentityManager.js";
+import W from "@arcgis/core/portal/Portal.js";
+import { getEmbeddingAIUtilityServiceUrl as $ } from "../../chunks/aiUtilityService.js";
+import { Annotation as R, isGraphInterrupt as j, StateGraph as O, START as H, END as N, MemorySaver as G } from "@langchain/langgraph/web";
+import { generateGuid as q } from "@arcgis/toolkit/string";
+import { d as z, r as b, m as V, c as B } from "../../chunks/runtime2.js";
+import { HumanMessage as Q, AIMessage as L } from "@langchain/core/messages";
+import { sendTraceMessage as l } from "../signals.js";
+import { getStrings as x, getLocaleFromConfig as S } from "../../chunks/localization.js";
+import { z as E } from "zod";
+import { ChatPromptTemplate as J } from "@langchain/core/prompts";
+import { g as K, W as X } from "../../chunks/webmapSchema.js";
+import { createAgent as Y, summarizationMiddleware as Z, modelCallLimitMiddleware as ee } from "langchain";
+import { createChatModel as k } from "../models/chatModel.js";
+import { BaseCallbackHandler as te } from "@langchain/core/callbacks/base";
+import { getEmbeddings as ne } from "../embeddings/getEmbeddings.js";
+import * as re from "@arcgis/core/core/reactiveUtils.js";
+import se from "@arcgis/core/layers/FeatureLayer.js";
+import ae from "@arcgis/core/request.js";
+const ie = async (t) => {
+  const e = await oe(), r = await $("default"), s = W.getDefault(), a = (await P.getCredential(`${s.url}/sharing`)).token, o = {
+    type: "generateEmbeddings",
+    webmapEmbeddings: t,
+    auth: { apiUrl: r, token: a }
+  };
+  return e.postMessage(o), await new Promise((i, c) => {
+    const d = (g) => {
+      g.data === "completed" && (e.removeEventListener("message", d), i());
+    }, u = (g) => {
+      e.removeEventListener("message", d), c(g instanceof Error ? g : new Error("Embeddings worker error"));
+    };
+    e.addEventListener("message", d), e.addEventListener("error", u, { once: !0 });
+  }), e;
+}, oe = async () => {
+  {
+    const t = (await import("../../chunks/embeddings.worker.js")).default;
+    return new t();
+  }
+}, ce = R.Root({
+  agentExecutionContext: R({
+    default: B,
+    reducer: V
+  }),
+  currentIntent: R({
+    default: () => "none",
+    reducer: b
+  }),
+  routing: R({
+    default: () => ({ mode: "auto" }),
+    reducer: b
+  }),
+  lastExecutedAgent: R({
+    default: () => "",
+    reducer: b
+  }),
+  requiresFollowUp: R({
+    default: () => !0,
+    reducer: b
+  }),
+  stepCount: R({
+    default: () => 0,
+    reducer: (t, e) => e ?? t + 1
+  }),
+  finalOutputMessage: R({
+    default: () => "",
+    reducer: z
+  })
+}), de = (t) => {
+  if (!t || typeof t != "object" || !("services" in t))
+    return !1;
+  const e = t.services;
+  return !!e && typeof e == "object" && "agentRegistry" in e;
+}, A = (t) => {
+  const e = t?.configurable;
+  return de(e) ? e : void 0;
+}, ue = (t) => {
+  t.currentIntent = "none";
+}, ge = async (t, e) => {
+  const r = A(e), s = await x({
+    path: "./assets/orchestrator/t9n",
+    locale: S(e)
+  });
+  if (t.agentExecutionContext.userRequest) {
+    const a = new Q(t.agentExecutionContext.userRequest.trim());
+    t.agentExecutionContext.messages = [...t.agentExecutionContext.messages, a], ue(t);
+  }
+  const n = r?.services.agentRegistry.list().map((a) => a.agent.id) ?? [];
+  return await l(
+    { text: s.availableAgents.replace("{agentIds}", [...n].join(", ")) },
+    e
+  ), await l({ text: s.analyzingUserInput }, e), t;
+}, le = async (t, e) => {
+  const r = await x({
+    path: "./assets/orchestrator/t9n",
+    locale: S(e)
+  });
+  return await l({ text: r.exiting }, e), t;
+}, I = (t) => typeof t == "object" && t !== null && !Array.isArray(t), he = (t, e) => {
+  if (!I(t)) {
+    t !== void 0 && console.warn(`Agent "${e}" returned invalid sharedStatePatch. Ignoring it.`);
+    return;
+  }
+  const r = {};
+  for (const [s, n] of Object.entries(t)) {
+    if (!I(n) || !("value" in n)) {
+      console.warn(
+        `Agent "${e}" returned invalid sharedStatePatch entry for key "${s}". Ignoring that entry.`
+      );
+      continue;
+    }
+    r[s] = { value: n.value };
+  }
+  return r;
+}, pe = (t) => {
+  const { previousSharedState: e, patch: r, agentId: s } = t;
+  if (!r)
+    return e;
+  const n = Date.now(), a = {
+    ...e
+  };
+  for (const [o, i] of Object.entries(r))
+    i?.value !== void 0 && (a[o] = {
+      value: i.value,
+      meta: {
+        updatedByAgentId: s,
+        updatedAt: n
+      }
+    });
+  return a;
+}, me = 256, fe = /* @__PURE__ */ new Set(["point", "polyline", "polygon", "extent", "custom"]), we = (t) => typeof t == "object" && t !== null && !Array.isArray(t), ye = (t, e) => {
+  if (t === void 0)
+    return;
+  if (!Array.isArray(t)) {
+    console.warn(`Agent "${e}" returned invalid sharedResourceAdditions. Ignoring it.`);
+    return;
+  }
+  const r = [];
+  for (const [s, n] of t.entries()) {
+    if (!we(n) || typeof n.kind != "string" || !fe.has(n.kind) || typeof n.description != "string" || !n.description.trim() || !("payload" in n) || n.payload === void 0) {
+      console.warn(
+        `Agent "${e}" returned invalid sharedResourceAdditions entry at index ${s}. Ignoring that entry.`
+      );
+      continue;
+    }
+    let a;
+    try {
+      a = structuredClone(n.payload);
+    } catch {
+      console.warn(
+        `Agent "${e}" returned invalid sharedResourceAdditions entry at index ${s}. Ignoring that entry.`
+      );
+      continue;
+    }
+    r.push({
+      kind: n.kind,
+      description: n.description.trim().slice(0, me),
+      payload: a
+    });
+  }
+  return r.length ? r : void 0;
+}, Ee = (t) => {
+  const { previousSharedResources: e, additions: r, agentId: s } = t;
+  if (!r?.length)
+    return e;
+  const n = Date.now(), a = r.map((o) => ({
+    ...o,
+    id: q(),
+    meta: {
+      createdByAgentId: s,
+      createdAt: n
+    }
+  }));
+  return [...e, ...a].slice(-50);
+}, M = (t) => {
+  if (typeof t != "string")
+    return;
+  const e = t.trim();
+  return e || void 0;
+}, Re = (t) => {
+  switch (t) {
+    case "failed":
+      return "Agent failed without a summary.";
+    case "unknown":
+      return "Agent returned with unknown status.";
+    case "success":
+      return "Agent completed without a summary.";
+    default:
+      return "Agent completed without a summary.";
+  }
+}, ve = (t, e) => {
+  const r = M(e?.outputMessage), s = M(e?.summary), n = e?.status, a = n === "success" || n === "failed" ? n : "unknown";
+  a === "unknown" && console.warn(`Agent "${t}" returned missing/invalid status. Defaulting to "unknown".`);
+  const o = he(e?.sharedStatePatch, t), i = ye(e?.sharedResourceAdditions, t);
+  return {
+    outputMessage: r,
+    summary: s ?? r ?? Re(a),
+    status: a,
+    sharedStatePatch: o,
+    sharedResourceAdditions: i
+  };
+}, F = 4e3, xe = async (t, e) => {
+  const r = A(e), s = await x({
+    path: "./assets/orchestrator/t9n",
+    locale: S(e)
+  });
+  if (e?.signal?.aborted)
+    return await l({ text: s.runCancelledAgentExecution }, e), {
+      ...t,
+      currentIntent: "none",
+      requiresFollowUp: !1
+    };
+  const { agentRegistry: n } = r?.services ?? {}, a = n?.get(t.currentIntent);
+  if (!a)
+    return console.warn(s.noAgentFoundForIntent.replace("{intent}", t.currentIntent)), t;
+  await l(
+    { text: s.executingRegisteredAgent.replace("{agentName}", a.agent.name) },
+    e
+  );
+  const o = {
+    ...e ?? {},
+    metadata: {
+      ...e?.metadata,
+      agentId: a.agent.id
+    },
+    configurable: {
+      ...r ?? {},
+      agentId: a.agent.id,
+      context: a.getContext ? await a.getContext() : void 0
+    }
+  };
+  let i;
+  try {
+    const u = await a.agent.createGraph().compile().invoke(
+      {
+        agentExecutionContext: {
+          ...t.agentExecutionContext,
+          // deep clone on messages did not work in agents, so its a shallow clone here.
+          messages: [...t.agentExecutionContext.messages],
+          // deep clone to prevent accidental mutations by agents
+          priorSteps: structuredClone(t.agentExecutionContext.priorSteps ?? []),
+          sharedState: structuredClone(t.agentExecutionContext.sharedState ?? {}),
+          sharedResources: structuredClone(t.agentExecutionContext.sharedResources ?? [])
+        }
+      },
+      o
+    );
+    i = ve(a.agent.name, u), await l(
+      { text: s.finishedExecutingRegisteredAgent.replace("{agentName}", a.agent.name) },
+      e
+    );
+  } catch (u) {
+    if (j(u) || e?.signal?.aborted || u instanceof Error && u.name === "AbortError")
+      throw u;
+    const g = u instanceof Error ? u.message : String(u);
+    console.error(`Agent "${a.agent.name}" failed:`, u), await l(
+      {
+        text: s.registeredAgentFailed.replace("{agentName}", a.agent.name).replace("{error}", g)
+      },
+      e
+    ), i = {
+      status: "failed",
+      outputMessage: s.agentExecutionFailed.replace("{error}", g),
+      summary: s.agentExecutionFailed.replace("{error}", g)
+    };
+  }
+  const c = i.outputMessage, d = [...t.agentExecutionContext.messages];
+  if (c) {
+    const u = c.length > F ? `${c.slice(0, F - 14)}
+[truncated]` : c;
+    d.push(new L(u));
+  }
+  return {
+    ...t,
+    stepCount: t.stepCount + 1,
+    lastExecutedAgent: a.agent.id,
+    requiresFollowUp: i.status === "failed" ? !0 : t.requiresFollowUp,
+    finalOutputMessage: c ?? "",
+    agentExecutionContext: {
+      ...t.agentExecutionContext,
+      messages: d,
+      priorSteps: [
+        ...t.agentExecutionContext.priorSteps ?? [],
+        {
+          agentId: a.agent.id,
+          assignedTask: t.agentExecutionContext.assignedTask,
+          summary: i?.summary || s.noSummaryProvided,
+          status: i?.status || "unknown"
+        }
+      ],
+      sharedState: pe({
+        previousSharedState: t.agentExecutionContext.sharedState,
+        patch: i.sharedStatePatch,
+        agentId: a.agent.id
+      }),
+      sharedResources: Ee({
+        previousSharedResources: t.agentExecutionContext.sharedResources,
+        additions: i.sharedResourceAdditions,
+        agentId: a.agent.id
+      })
+    }
+  };
+}, Se = async (t) => {
+  const { agent: e, messages: r, config: s } = t;
+  return { structuredResponse: (await e.invoke(
+    {
+      messages: r
+    },
+    s
+  )).structuredResponse };
+}, be = E.object({
+  id: E.string().min(1),
+  name: E.string().min(1),
+  description: E.string().min(1)
+});
+E.array(be);
+const _ = (t) => JSON.stringify(t, null, 2), Ce = (t) => {
+  const e = t.map((s) => s.id), r = E.enum(e);
+  return E.object({
+    intent: r.nullable(),
+    assignedTask: E.string().nullable(),
+    requiresFollowUp: E.boolean()
+  });
+}, Ae = async (t, e) => {
+  const r = A(e), s = await x({
+    path: "./assets/orchestrator/t9n",
+    locale: S(e)
+  });
+  if (e?.signal?.aborted)
+    return await l({ text: s.runCancelled }, e), {
+      ...t,
+      currentIntent: "none",
+      finalOutputMessage: s.runCancelled,
+      requiresFollowUp: !1
+    };
+  try {
+    await l({ text: s.routingToAgent }, e);
+    const a = r.services.agentRegistry?.list() ?? [], o = a.map(({ agent: h }) => ({
+      id: h.id,
+      name: h.name,
+      description: h.description
+    }));
+    if (!o.length)
+      return await l({ text: s.noAgentsRegisteredTrace }, e), {
+        ...t,
+        currentIntent: "none",
+        finalOutputMessage: s.noAgentsRegisteredMessage
+      };
+    const i = await K("intent_prompt"), c = _(o), d = Ce(o), u = {
+      registeredAgents: c,
+      priorSteps: _(t.agentExecutionContext.priorSteps),
+      userRequest: t.agentExecutionContext.userRequest
+    }, p = await J.fromTemplate(i).format(u), v = Y({
+      model: await k({
+        modelTier: "fast",
+        config: e
+      }),
+      tools: [],
+      systemPrompt: p,
+      responseFormat: d,
+      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.
+        Z({
+          model: await k({
+            modelTier: "fast",
+            config: e
+          }),
+          trigger: { tokens: 4e3 },
+          keep: { messages: 6 }
+        }),
+        // Enforce no loop/retry.
+        // 1 usual LLM call and 1 optional summarization call.
+        ee({ runLimit: 2 })
+      ]
+    }), { structuredResponse: m } = await Se({
+      agent: v,
+      messages: t.agentExecutionContext.messages,
+      config: e
+    }), f = d.parse(
+      m ?? { intent: null, assignedTask: null, requiresFollowUp: !1 }
+    ), w = f.intent ?? "none", y = {
+      ...t,
+      currentIntent: w,
+      requiresFollowUp: f.requiresFollowUp,
+      agentExecutionContext: {
+        ...t.agentExecutionContext,
+        assignedTask: f.assignedTask ?? ""
+      }
+    };
+    if (w === "none") {
+      const h = s.noMatchingAgentMessage.replace(
+        "{agentNames}",
+        a.map(({ agent: C }) => C.name).join(", ")
+      );
+      return await l({ text: s.noMatchingAgentTrace }, e), {
+        ...t,
+        currentIntent: w,
+        requiresFollowUp: !1,
+        finalOutputMessage: h,
+        agentExecutionContext: {
+          ...t.agentExecutionContext,
+          assignedTask: "",
+          messages: [...t.agentExecutionContext.messages, new L(h)],
+          priorSteps: [
+            ...t.agentExecutionContext.priorSteps ?? [],
+            {
+              agentId: "no-intent-router",
+              assignedTask: t.agentExecutionContext.userRequest,
+              summary: "No matching agent found; asked user to rephrase.",
+              status: "failed"
+            }
+          ]
+        }
+      };
+    }
+    return await l(
+      {
+        text: s.agentPicked.replace("{intent}", w).replace("{assignedTask}", f.assignedTask ?? "").replace("{requiresFollowUp}", String(f.requiresFollowUp))
+      },
+      e
+    ), y;
+  } catch (n) {
+    throw await l({ text: s.intentDetectionErrorTrace }, e), new Error(
+      s.intentDetectionError.replace("{error}", n instanceof Error ? n.message : String(n))
+    );
+  }
+}, ke = async (t, e) => {
+  const r = await x({
+    path: "./assets/orchestrator/t9n",
+    locale: S(e)
+  });
+  if (t.routing.mode !== "direct")
+    throw new Error(r.directAgentAssignmentRequiresDirectRouting);
+  return await l({ text: r.directRouteToAgent.replace("{agentId}", t.routing.agentId) }, e), {
+    ...t,
+    currentIntent: t.routing.agentId,
+    requiresFollowUp: !1,
+    agentExecutionContext: {
+      ...t.agentExecutionContext,
+      assignedTask: t.agentExecutionContext.userRequest
+    }
+  };
+}, Ie = 3, Me = (t) => t.routing.mode === "direct" ? "assignDirectAgent" : "intentLLM", Fe = (t) => t.routing.mode === "direct" || t.stepCount >= Ie || !t.requiresFollowUp ? "exit" : "intentLLM", _e = () => new O(ce).addNode("ingestInput", ge).addNode("assignDirectAgent", ke).addNode("intentLLM", Ae).addNode("executeRegisteredAgent", xe).addNode("exit", le).addEdge(H, "ingestInput").addConditionalEdges("ingestInput", Me).addEdge("assignDirectAgent", "executeRegisteredAgent").addConditionalEdges("intentLLM", (e) => e.currentIntent === "none" || e.currentIntent === e.lastExecutedAgent ? "exit" : "executeRegisteredAgent").addConditionalEdges("executeRegisteredAgent", Fe).addEdge("exit", N), Te = (t, e) => {
+  const r = t.output?.usage_metadata ?? e.usage_metadata, s = t.output?.llmOutput?.tokenUsage, n = r?.input_tokens ?? s?.promptTokens, a = r?.output_tokens ?? s?.completionTokens, o = r?.total_tokens ?? s?.totalTokens;
+  if (n === void 0 || a === void 0 || o === void 0)
+    return;
+  const i = r?.input_token_details?.cache_read, c = r?.input_token_details?.cache_creation, d = r?.output_token_details?.reasoning;
+  return {
+    input: n,
+    output: a,
+    total: o,
+    ...i !== void 0 && { cacheRead: i },
+    ...c !== void 0 && { cacheWrite: c },
+    ...d !== void 0 && { reasoning: d }
+  };
+}, qe = (t, e, r, s) => {
+  switch (t) {
+    case "chat_model":
+    case "llm":
+      return "model";
+    case "tool":
+    case "retriever":
+      return t;
+    case "chain":
+      return !s || e === "LangGraph" ? "workflow" : r === e ? "node" : "chain";
+    default:
+      return;
+  }
+}, Le = (t) => {
+  if (t instanceof Error)
+    return { message: t.message, name: t.name };
+  const e = t, r = typeof e?.message == "string" ? e.message : String(t ?? "Unknown runtime error"), s = typeof e?.name == "string" ? e.name : void 0;
+  return { message: r, ...s && { name: s } };
+}, De = ({
+  event: t,
+  runId: e,
+  parentSpanId: r,
+  timestamp: s
+}) => {
+  const n = /^on_(.+)_(start|end|error)$/u.exec(t.event);
+  if (!n)
+    return;
+  const [, a, o] = n, i = t.metadata ?? {}, c = i.langgraph_node, d = qe(a, t.name, c, r);
+  if (!d)
+    return;
+  const u = i.agentId, g = i.model ?? i.ls_model_name, p = t.data, v = o === "end" && d === "model" ? Te(p, i) : void 0, m = t.tags?.includes("langsmith:hidden") || c === "__start__", f = {
+    ...g && { model: g },
+    ...v && { tokenUsage: v },
+    ...m && { internal: !0 }
+  }, w = {
+    id: t.run_id,
+    ...r && { parentId: r },
+    label: t.name,
+    type: d,
+    ...Object.keys(f).length && { metadata: f }
+  }, y = { runId: e, timestamp: s, type: "runtime", ...u && { agentId: u } };
+  switch (o) {
+    case "start":
+      return {
+        ...y,
+        phase: "started",
+        span: {
+          ...w,
+          ...p?.input !== void 0 && { input: p.input }
+        }
+      };
+    case "end":
+      return {
+        ...y,
+        phase: "completed",
+        span: {
+          ...w,
+          ...p?.output !== void 0 && { output: p.output }
+        }
+      };
+    case "error":
+      return { ...y, phase: "failed", span: { ...w, error: Le(p?.error) } };
+    default:
+      return;
+  }
+};
+class T {
+  constructor() {
+    this.agentRegistry = /* @__PURE__ */ new Map();
+  }
+  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, e);
+  }
+  get(e) {
+    return this.agentRegistry.get(e);
+  }
+  list() {
+    return [...this.agentRegistry.values()];
+  }
+}
+class Ue {
+  /**
+   * Create a new InterruptHandler tied to a specific compiled graph and config.
+   */
+  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((e, r) => {
+      this.resolveWait = e, this.rejectWait = r;
+    });
+  }
+  /**
+   * Resume graph execution after the UI responds to an interrupt.
+   */
+  handle(e, r) {
+    try {
+      const s = {
+        agentId: e.agentId,
+        id: e.id,
+        payload: r
+      }, n = this.graph.streamEvents(null, {
+        ...this.config,
+        configurable: {
+          ...this.config.configurable,
+          hitlResponse: s
+        },
+        subgraphs: !0,
+        version: "v2"
+      });
+      this.resolveWait?.(n);
+    } catch (s) {
+      this.rejectWait?.(s);
+    } finally {
+      this.resolveWait = void 0, this.rejectWait = void 0;
+    }
+  }
+  /**
+   * Abort the HITL wait and reject any pending continuation.
+   */
+  cancel() {
+    this.rejectWait && (this.rejectWait(new Error("Request cancelled by user.")), this.resolveWait = void 0, this.rejectWait = void 0);
+  }
+}
+const D = async (t, e) => {
+  const r = e.get(t);
+  if (r)
+    return r;
+  const s = await ne([t]);
+  return e.set(t, s[0]), s[0];
+};
+async function Pe(t, e, r, s) {
+  const n = `req-${Date.now()}`, o = {
+    type: "layerSearch",
+    precomputedEmbedding: s ? await D(t, s) : void 0,
+    requestId: n,
+    minScore: r
+  };
+  return await new Promise((i) => {
+    const c = (d) => {
+      d.data.requestId === n && i(d.data.results);
+    };
+    e.addEventListener("message", c, { once: !0 }), e.postMessage(o);
+  });
+}
+function We(t) {
+  const { worker: e } = t;
+  return {
+    async searchLayers({
+      text: r,
+      minScore: s,
+      embeddingCache: n
+    }) {
+      return await Pe(r, e, s, n);
+    }
+  };
+}
+const $e = async ({
+  combinedQuery: t,
+  layerIds: e,
+  embeddingsWorker: r,
+  minScore: s,
+  topResults: n,
+  embeddingCache: a
+}) => {
+  const o = `req-${Date.now()}`, i = a ? await D(t, a) : void 0, c = {
+    type: "fieldSearch",
+    layerIdForFieldsSearch: e,
+    precomputedEmbedding: i,
+    requestId: o,
+    minScore: s,
+    topResults: n
+  };
+  return await new Promise((d) => {
+    const u = (g) => {
+      if (g.data.requestId !== o)
+        return;
+      const p = g.data.results.map(({ layerId: v, results: m }) => ({
+        layerId: v,
+        results: m
+      }));
+      d(p);
+    };
+    r.addEventListener("message", u, { once: !0 }), r.postMessage(c);
+  });
+};
+function je(t) {
+  const { worker: e } = t;
+  return {
+    async searchFields({ text: r, layerIds: s, minScore: n, topResults: a, embeddingCache: o }) {
+      return await $e({
+        combinedQuery: r,
+        layerIds: s,
+        embeddingsWorker: e,
+        minScore: n,
+        topResults: a,
+        embeddingCache: o
+      });
+    }
+  };
+}
+const Oe = (t) => {
+  const e = X.safeParse(t);
+  if (!e.success)
+    throw new Error("Embeddings response validation failed. Regenerate embeddings.");
+  return e.data;
+}, He = (t, e) => {
+  const r = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Map();
+  if (e.allLayers.forEach((n) => {
+    n instanceof se && s.set(n.id, n);
+  }), t.length !== s.size)
+    throw new Error("Layer count mismatch during registry restoration. Regenerate embeddings.");
+  for (const n of t) {
+    const a = s.get(n.id);
+    if (!a)
+      throw new Error(
+        `Layer with ID ${n.id} not found in the original map during registry restoration. Regenerate embeddings.`
+      );
+    if (n.fields.length !== a.fields.length)
+      throw new Error(
+        `Field count mismatch for layer ID ${n.id} during registry restoration. Regenerate embeddings.`
+      );
+    const o = {
+      name: n.name,
+      title: n.title,
+      description: n.description
+    }, i = /* @__PURE__ */ new Map();
+    for (const c of n.fields) {
+      const d = a.fieldsIndex.get(c.name);
+      if (!d)
+        throw new Error(
+          `Field with name ${c.name} not found in the original layer ${n.id} during registry restoration. Regenerate embeddings.`
+        );
+      i.set(c.name, {
+        name: c.name,
+        alias: a.getFieldAlias(c.name) ?? c.alias,
+        description: c.description,
+        type: d.type || "unknown",
+        valueType: d.valueType || "unknown",
+        domain: a.getFieldDomain(c.name) ?? void 0
+      });
+    }
+    r.set(n.id, {
+      layerItem: o,
+      fieldRegistry: i
+    });
+  }
+  return r;
+}, Ne = async (t) => {
+  try {
+    return (await ae(t, {
+      responseType: "json"
+    })).data;
+  } catch (e) {
+    throw new Error(`Failed to fetch data from ${t}: ${String(e)}`);
+  }
+}, Ge = async (t) => {
+  const e = t.map;
+  if (!e?.portalItem)
+    throw new Error("WebMap portal item is missing.");
+  const { resources: r } = await e.portalItem.fetchResources(), s = r.find((o) => o.resource.path === "embeddings-v01.json");
+  if (!s?.resource.url)
+    throw new Error("Embeddings resource 'embeddings-v01.json' not found in the webmap portal item.");
+  const n = await Ne(s.resource.url);
+  return Oe(n);
+};
+class U {
+  constructor() {
+    this.orchestratorReady = !1, this.chatHistory = [], this.priorSteps = [], this.sharedState = {}, this.sharedResources = [], this.agentRegistry = new T(), this.activeRunId = "", this.cancelledRunIds = /* @__PURE__ */ new Set(), this.parentRunIds = /* @__PURE__ */ new Map(), this.activeRuntimeSpans = /* @__PURE__ */ new Map(), this.runtimeEventsEnabled = !1, this.streamEpoch = 0;
+  }
+  /**
+   * Creates and returns an AI-ready Orchestrator instance.
+   * @param deps Core dependencies (layer/field registry plus optional map views).
+   * @returns Ready Orchestrator.
+   */
+  static async init(e) {
+    const r = new U();
+    r.runtimeEventsEnabled = e.runtimeEventsEnabled ?? !1;
+    try {
+      if (e.view?.map) {
+        await re.whenOnce(() => e.view.ready);
+        const s = await Ge(e.view), n = He(
+          s.layers,
+          e.view.map
+        );
+        r.layersAndFieldsRegistry = n, r.embeddingsWorker = await ie(s);
+      }
+      return e.agents?.forEach((s) => {
+        r.agentRegistry.register(s);
+      }), r.orchestratorReady = !0, r;
+    } catch (s) {
+      throw console.error("Orchestrator initialization failed:", s), s;
+    }
+  }
+  /**
+   * Run a new chat turn through the graph.
+   * Yields structured events for the UI to consume:
+   *  - `trace`: intermediate model output
+   *  - `interrupt`: HITL required, wait for `resumeInterrupt()`
+   *  - `completed`: final result with chat history + layer styling
+   *  - `cancelled`: user aborted the run
+   * @param userInput User request to process.
+   * @param options Agent selection and routing behavior and locale for this run.
+   */
+  async *ask(e, r = {}) {
+    if (!this.orchestratorReady)
+      throw new Error("Orchestrator is not ready yet.");
+    if (!this.agentRegistry.list().length)
+      throw new Error("Orchestrator has no registered agents.");
+    const s = this.createRequestAgentRegistry(r);
+    if (!s.list().length)
+      throw new Error("Orchestrator has no agents selected for this request.");
+    if (++this.streamEpoch, !e.trim() && !r.inputParts?.length)
+      return;
+    if (!e.trim() && r.routing !== "direct")
+      throw new Error("Requests containing only structured input require direct agent routing.");
+    const n = q();
+    this.parentRunIds.clear(), this.activeRuntimeSpans.clear(), this.activeRunId = n, this.activeAbortController = new AbortController(), this.graph || (this.graph = _e().compile({ checkpointer: new G() }));
+    const a = this.embeddingsWorker ? We({ worker: this.embeddingsWorker }) : void 0, o = this.embeddingsWorker ? je({ worker: this.embeddingsWorker }) : void 0, i = /* @__PURE__ */ new Map(), c = r.routing === "direct" ? { mode: "direct", agentId: r.agentId } : { mode: "auto" }, d = {
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      thread_id: n,
+      locale: r.locale ?? "en",
+      hitlResponse: null,
+      services: {
+        layerSearch: a,
+        fieldSearch: o,
+        layersAndFieldsRegistry: this.layersAndFieldsRegistry,
+        agentRegistry: s,
+        embeddingCache: i
+      }
+    }, u = {
+      version: "v2",
+      streamMode: "custom",
+      signal: this.activeAbortController.signal,
+      ...this.runtimeEventsEnabled && { callbacks: [this.createHierarchyCallback()] },
+      configurable: d,
+      subgraphs: !0
+    }, g = this.graph?.streamEvents(
+      {
+        routing: c,
+        agentExecutionContext: {
+          userRequest: e,
+          inputParts: [...r.inputParts ?? []],
+          messages: this.chatHistory,
+          priorSteps: this.priorSteps,
+          sharedState: this.sharedState,
+          sharedResources: this.sharedResources
+        }
+      },
+      u
+    ), p = ++this.streamEpoch;
+    if (yield* this.pipeStream(g, p, n), this.isRunCancelled(n)) {
+      yield* this.createCancellationEvents(n);
+      return;
+    }
+    for (; ; ) {
+      if (this.isRunCancelled(n)) {
+        yield* this.createCancellationEvents(n);
+        return;
+      }
+      const y = (await this.graph.getState(u, { subgraphs: !0 })).tasks.find((h) => h.interrupts.length > 0)?.interrupts[0]?.value;
+      if (!y)
+        break;
+      this.currentInterrupt = y, this.interruptHandler = new Ue(this.graph, u), yield* this.closeActiveRuntimeSpans(n, "interrupted"), yield { runId: n, timestamp: Date.now(), type: "interrupt", interrupt: y };
+      try {
+        const h = await this.interruptHandler.waitForUser(), C = ++this.streamEpoch;
+        yield* this.pipeStream(h, C, n);
+      } catch (h) {
+        if (this.isRunCancelled(n)) {
+          yield* this.createCancellationEvents(n);
+          return;
+        }
+        if (h) {
+          yield {
+            runId: n,
+            timestamp: Date.now(),
+            type: "error",
+            error: { message: h?.message }
+          };
+          return;
+        }
+      }
+    }
+    if (this.isRunCancelled(n)) {
+      yield* this.createCancellationEvents(n);
+      return;
+    }
+    const m = (await this.graph.getState(u, { subgraphs: !0 })).values;
+    if (this.isRunCancelled(n)) {
+      yield* this.createCancellationEvents(n);
+      return;
+    }
+    this.chatHistory = m.agentExecutionContext.messages.length ? m.agentExecutionContext.messages : this.chatHistory, this.priorSteps = m.agentExecutionContext.priorSteps?.slice(-5) ?? [], this.sharedState = m.agentExecutionContext.sharedState ?? {}, this.sharedResources = m.agentExecutionContext.sharedResources ?? [], yield {
+      runId: n,
+      timestamp: Date.now(),
+      type: "completed",
+      result: { content: m.finalOutputMessage }
+    };
+  }
+  /**
+   * Start a new conversation by clearing chat history, prior steps, and shared state.
+   */
+  newConversation() {
+    this.chatHistory = [], this.priorSteps = [], this.sharedState = {}, this.sharedResources = [];
+  }
+  /**
+   * Generic resume for any HITL interrupt.
+   * The payload is whatever the UI collected (e.g. "yes", "no", layerId, etc).
+   */
+  resumeInterrupt(e) {
+    if (!this.currentInterrupt || !this.interruptHandler)
+      throw new Error("No pending interrupt to resume.");
+    this.interruptHandler.handle(this.currentInterrupt, e);
+  }
+  /**
+   * Optional: allow UI to cancel the current HITL.
+   */
+  cancelInterrupt() {
+    this.interruptHandler && this.interruptHandler.cancel();
+  }
+  /**
+   * Cancels the active run.
+   *
+   * - Aborts in-flight work for consumers that honor AbortSignal.
+   * - Invalidates active stream iterators via epoch bump.
+   * - Unblocks any pending HITL wait.
+   */
+  cancel() {
+    this.activeRunId && (this.cancelledRunIds.add(this.activeRunId), this.activeAbortController?.abort(), ++this.streamEpoch, this.interruptHandler?.cancel());
+  }
+  async *pipeStream(e, r, s) {
+    try {
+      for await (const n of e) {
+        if (this.isRunCancelled(s) || r !== this.streamEpoch)
+          break;
+        if (this.runtimeEventsEnabled) {
+          const a = De({
+            event: n,
+            runId: s,
+            parentSpanId: this.parentRunIds.get(n.run_id),
+            timestamp: Date.now()
+          });
+          a && (a.phase === "started" ? this.activeRuntimeSpans.set(a.span.id, a) : this.activeRuntimeSpans.delete(a.span.id), yield a);
+        }
+        n.event === "on_custom_event" && n.name === "trace_message" ? yield { runId: s, timestamp: Date.now(), type: "trace", data: n.data } : n.name === "graph_ux_suggestion" && (yield {
+          runId: s,
+          timestamp: Date.now(),
+          type: "ux-suggestion",
+          suggestion: n.data
+        });
+      }
+    } catch (n) {
+      if (!this.isRunCancelled(s))
+        throw n;
+    }
+  }
+  *createCancellationEvents(e) {
+    yield* this.closeActiveRuntimeSpans(e, "cancelled"), yield { runId: e, timestamp: Date.now(), type: "cancelled", reason: "user" };
+  }
+  *closeActiveRuntimeSpans(e, r) {
+    const s = Date.now(), n = [...this.activeRuntimeSpans.values()].reverse();
+    this.activeRuntimeSpans.clear();
+    for (const a of n) {
+      const { input: o, ...i } = a.span;
+      yield {
+        type: "runtime",
+        phase: r,
+        runId: e,
+        timestamp: s,
+        ...a.agentId && { agentId: a.agentId },
+        span: i
+      };
+    }
+  }
+  // v2 stream events omit parent run IDs, so capture them through callbacks to preserve the normalized span hierarchy.
+  createHierarchyCallback() {
+    const e = (r, s) => {
+      s && this.parentRunIds.set(r, s);
+    };
+    return te.fromMethods({
+      handleLLMStart: (r, s, n, a) => e(n, a),
+      handleChatModelStart: (r, s, n, a) => e(n, a),
+      handleChainStart: (r, s, n, a) => e(n, a),
+      handleToolStart: (r, s, n, a) => e(n, a),
+      handleRetrieverStart: (r, s, n, a) => e(n, a)
+    });
+  }
+  isRunCancelled(e) {
+    return this.cancelledRunIds.has(e);
+  }
+  /**
+   * Creates a request-scoped registry containing all agents by default,
+   * or only the explicitly selected agents when filtering is requested.
+   */
+  createRequestAgentRegistry(e) {
+    const r = e.routing === "direct" ? [e.agentId] : e.agentIds, s = r ? r.map((a) => {
+      const o = this.agentRegistry.get(a);
+      if (!o)
+        throw new Error(`Agent is not registered: ${a}`);
+      return o;
+    }) : this.agentRegistry.list(), n = new T();
+    return s.forEach((a) => n.register(a)), n;
+  }
+  /**
+   * Disposes this instance by terminating the embeddings worker
+   * and cleaning up all related resources.
+   */
+  dispose() {
+    this.sharedResources = [], this.embeddingsWorker && (this.embeddingsWorker.terminate(), this.embeddingsWorker = void 0), this.orchestratorReady = !1;
+  }
+}
+export {
+  U as Orchestrator
+};