@arcgis/ai-components 5.2.0-next.65 → 5.2.0-next.67

package/dist/chunks/orchestrator.js

@@ -1,81 +1,81 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
-import R from "@arcgis/core/identity/IdentityManager.js";
+import A from "@arcgis/core/identity/IdentityManager.js";
 import C from "@arcgis/core/portal/Portal.js";
-import { n as I, o as v, D as k, p as A, q as M, W as F } from "./generateLayerDescriptions.js";
-import { isGraphInterrupt as D, StateGraph as L, START as W, END as $, MemorySaver as j } from "@langchain/langgraph/web";
-import { generateGuid as q } from "@arcgis/toolkit/string";
-import { HumanMessage as H, AIMessage as P } from "@langchain/core/messages";
+import { n as k, o as b, D as M, p as D, q as F, W as $ } from "./generateLayerDescriptions.js";
+import { isGraphInterrupt as L, StateGraph as W, START as q, END as j, MemorySaver as H } from "@langchain/langgraph/web";
+import { generateGuid as P } from "@arcgis/toolkit/string";
+import { HumanMessage as O, AIMessage as T } from "@langchain/core/messages";
 import { s as l } from "./index.js";
-import * as O from "@arcgis/core/core/reactiveUtils.js";
-import T from "@arcgis/core/layers/FeatureLayer.js";
-import U from "@arcgis/core/request.js";
-const G = async (t) => {
-  const e = await N(), r = await I("default"), s = C.getDefault(), o = (await R.getCredential(`${s.url}/sharing`)).token, i = {
+import * as U from "@arcgis/core/core/reactiveUtils.js";
+import N from "@arcgis/core/layers/FeatureLayer.js";
+import G from "@arcgis/core/request.js";
+const _ = async (t) => {
+  const e = await V(), n = await k("default"), s = C.getDefault(), a = (await A.getCredential(`${s.url}/sharing`)).token, i = {
     type: "generateEmbeddings",
     webmapEmbeddings: t,
-    auth: { apiUrl: r, token: o }
+    auth: { apiUrl: n, token: a }
   };
   return e.postMessage(i), await new Promise((c, d) => {
-    const a = (u) => {
-      u.data === "completed" && (e.removeEventListener("message", a), c());
+    const o = (u) => {
+      u.data === "completed" && (e.removeEventListener("message", o), c());
     }, g = (u) => {
-      e.removeEventListener("message", a), d(u instanceof Error ? u : new Error("Embeddings worker error"));
+      e.removeEventListener("message", o), d(u instanceof Error ? u : new Error("Embeddings worker error"));
     };
-    e.addEventListener("message", a), e.addEventListener("error", g, { once: !0 });
+    e.addEventListener("message", o), e.addEventListener("error", g, { once: !0 });
   }), e;
-}, N = async () => {
+}, V = async () => {
   {
     const t = (await import("./embeddings.worker.js")).default;
     return new t();
   }
-}, _ = (t) => {
+}, z = (t) => {
   t.currentIntent = "none";
-}, V = async (t, e) => {
-  const r = v(e);
+}, Q = async (t, e) => {
+  const n = b(e);
   if (t.agentExecutionContext.userRequest) {
-    const n = new H(t.agentExecutionContext.userRequest.trim());
-    t.agentExecutionContext.messages = [...t.agentExecutionContext.messages, n], _(t);
+    const r = new O(t.agentExecutionContext.userRequest.trim());
+    t.agentExecutionContext.messages = [...t.agentExecutionContext.messages, r], z(t);
   }
-  const s = r?.services.agentRegistry.list().map((n) => n.agent.id) ?? [];
+  const s = n?.services.agentRegistry.list().map((r) => r.agent.id) ?? [];
   return await l({ text: `Available agents: ${[...s].join(", ")}` }, e), await l({ text: "Analyzing user input" }, e), t;
-}, z = async (t, e) => (await l({ text: "Exiting..." }, e), t), w = (t) => typeof t == "object" && t !== null && !Array.isArray(t), Q = (t, e) => {
-  if (!w(t)) {
+}, B = async (t, e) => (await l({ text: "Exiting..." }, e), t), f = (t) => typeof t == "object" && t !== null && !Array.isArray(t), J = (t, e) => {
+  if (!f(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 (!w(n) || !("value" in n)) {
+  const n = {};
+  for (const [s, r] of Object.entries(t)) {
+    if (!f(r) || !("value" in r)) {
       console.warn(
         `Agent "${e}" returned invalid sharedStatePatch entry for key "${s}". Ignoring that entry.`
       );
       continue;
     }
-    r[s] = { value: n.value };
+    n[s] = { value: r.value };
   }
-  return r;
-}, B = (t) => {
-  const { previousSharedState: e, patch: r, agentId: s } = t;
-  if (!r)
+  return n;
+}, K = (t) => {
+  const { previousSharedState: e, patch: n, agentId: s } = t;
+  if (!n)
     return e;
-  const n = Date.now(), o = {
+  const r = Date.now(), a = {
     ...e
   };
-  for (const [i, c] of Object.entries(r))
-    c?.value !== void 0 && (o[i] = {
+  for (const [i, c] of Object.entries(n))
+    c?.value !== void 0 && (a[i] = {
       value: c.value,
       meta: {
         updatedByAgentId: s,
-        updatedAt: n
+        updatedAt: r
       }
     });
-  return o;
-}, f = (t) => {
+  return a;
+}, E = (t) => {
   if (typeof t != "string")
     return;
   const e = t.trim();
   return e || void 0;
-}, J = (t) => {
+}, X = (t) => {
   switch (t) {
     case "failed":
       return "Agent failed without a summary.";
@@ -86,39 +86,39 @@ const G = async (t) => {
     default:
       return "Agent completed without a summary.";
   }
-}, K = (t, e) => {
-  const r = f(e?.outputMessage), s = f(e?.summary), n = e?.status, o = n === "success" || n === "failed" ? n : "unknown";
-  o === "unknown" && console.warn(`Agent "${t}" returned missing/invalid status. Defaulting to "unknown".`);
-  const i = Q(e?.sharedStatePatch, t);
+}, Y = (t, e) => {
+  const n = E(e?.outputMessage), s = E(e?.summary), r = e?.status, a = r === "success" || r === "failed" ? r : "unknown";
+  a === "unknown" && console.warn(`Agent "${t}" returned missing/invalid status. Defaulting to "unknown".`);
+  const i = J(e?.sharedStatePatch, t);
   return {
-    outputMessage: r,
-    summary: s ?? r ?? J(o),
-    status: o,
+    outputMessage: n,
+    summary: s ?? n ?? X(a),
+    status: a,
     sharedStatePatch: i
   };
-}, E = 4e3, X = async (t, e) => {
-  const r = v(e);
+}, x = 4e3, Z = async (t, e) => {
+  const n = b(e);
   if (e?.signal?.aborted)
     return await l({ text: "Run cancelled; skipping agent execution" }, e), {
       ...t,
       currentIntent: "none",
       requiresFollowUp: !1
     };
-  const { agentRegistry: s } = r?.services ?? {}, n = s?.get(t.currentIntent);
-  if (!n)
+  const { agentRegistry: s } = n?.services ?? {}, r = s?.get(t.currentIntent);
+  if (!r)
     return console.warn(`No agent found for intent: ${t.currentIntent}`), t;
-  await l({ text: `Executing registered agent: ${n.agent.name}` }, e);
-  const o = {
+  await l({ text: `Executing registered agent: ${r.agent.name}` }, e);
+  const a = {
     ...e ?? {},
     configurable: {
-      ...r ?? {},
-      agentId: n.agent.id,
-      context: n.getContext ? await n.getContext() : void 0
+      ...n ?? {},
+      agentId: r.agent.id,
+      context: r.getContext ? await r.getContext() : void 0
     }
   };
   let i;
   try {
-    const a = await n.agent.createGraph().compile().invoke(
+    const o = await r.agent.createGraph().compile().invoke(
       {
         agentExecutionContext: {
           ...t.agentExecutionContext,
@@ -129,14 +129,14 @@ const G = async (t) => {
           sharedState: structuredClone(t.agentExecutionContext.sharedState ?? {})
         }
       },
-      o
+      a
     );
-    i = K(n.agent.name, a), await l({ text: `Finished executing registered agent: ${n.agent.name}` }, e);
-  } catch (a) {
-    if (D(a) || e?.signal?.aborted || a instanceof Error && a.name === "AbortError")
-      throw a;
-    const g = a instanceof Error ? a.message : String(a);
-    console.error(`Agent "${n.agent.name}" failed:`, a), await l({ text: `Registered agent failed: ${n.agent.name}. ${g}` }, e), i = {
+    i = Y(r.agent.name, o), await l({ text: `Finished executing registered agent: ${r.agent.name}` }, e);
+  } catch (o) {
+    if (L(o) || e?.signal?.aborted || o instanceof Error && o.name === "AbortError")
+      throw o;
+    const g = o instanceof Error ? o.message : String(o);
+    console.error(`Agent "${r.agent.name}" failed:`, o), await l({ text: `Registered agent failed: ${r.agent.name}. ${g}` }, e), i = {
       status: "failed",
       outputMessage: `Agent execution failed: ${g}`,
       summary: `Agent execution failed: ${g}`
@@ -144,14 +144,14 @@ const G = async (t) => {
   }
   const c = i.outputMessage, d = [...t.agentExecutionContext.messages];
   if (c) {
-    const a = c.length > E ? `${c.slice(0, E - 14)}
+    const o = c.length > x ? `${c.slice(0, x - 14)}
 [truncated]` : c;
-    d.push(new P(a));
+    d.push(new T(o));
   }
   return {
     ...t,
     stepCount: t.stepCount + 1,
-    lastExecutedAgent: n.agent.id,
+    lastExecutedAgent: r.agent.id,
     requiresFollowUp: i.status === "failed" ? !0 : t.requiresFollowUp,
     finalOutputMessage: c ?? "",
     agentExecutionContext: {
@@ -160,32 +160,41 @@ const G = async (t) => {
       priorSteps: [
         ...t.agentExecutionContext.priorSteps ?? [],
         {
-          agentId: n.agent.id,
+          agentId: r.agent.id,
           assignedTask: t.agentExecutionContext.assignedTask,
           summary: i?.summary || "No summary provided.",
           status: i?.status || "unknown"
         }
       ],
-      sharedState: B({
+      sharedState: K({
         previousSharedState: t.agentExecutionContext.sharedState,
         patch: i.sharedStatePatch,
-        agentId: n.agent.id
+        agentId: r.agent.id
       })
     }
   };
-}, Y = 3, Z = () => new L(k).addNode("ingestInput", V).addNode("intentLLM", A).addNode("executeRegisteredAgent", X).addNode("exit", z).addEdge(W, "ingestInput").addEdge("ingestInput", "intentLLM").addConditionalEdges("intentLLM", (e) => e.currentIntent === "none" || e.currentIntent === e.lastExecutedAgent ? "exit" : "executeRegisteredAgent").addConditionalEdges(
-  "executeRegisteredAgent",
-  (e) => e.stepCount >= Y || !e.requiresFollowUp ? "exit" : "intentLLM"
-).addEdge("exit", $);
-class ee {
+}, ee = async (t, e) => {
+  if (t.routing.mode !== "direct")
+    throw new Error("Direct agent assignment requires direct routing.");
+  return await l({ text: `Doing a direct route to agent: ${t.routing.agentId}` }, e), {
+    ...t,
+    currentIntent: t.routing.agentId,
+    requiresFollowUp: !1,
+    agentExecutionContext: {
+      ...t.agentExecutionContext,
+      assignedTask: t.agentExecutionContext.userRequest
+    }
+  };
+}, te = 3, re = (t) => t.routing.mode === "direct" ? "assignDirectAgent" : "intentLLM", ne = (t) => t.routing.mode === "direct" || t.stepCount >= te || !t.requiresFollowUp ? "exit" : "intentLLM", se = () => new W(M).addNode("ingestInput", Q).addNode("assignDirectAgent", ee).addNode("intentLLM", D).addNode("executeRegisteredAgent", Z).addNode("exit", B).addEdge(q, "ingestInput").addConditionalEdges("ingestInput", re).addEdge("assignDirectAgent", "executeRegisteredAgent").addConditionalEdges("intentLLM", (e) => e.currentIntent === "none" || e.currentIntent === e.lastExecutedAgent ? "exit" : "executeRegisteredAgent").addConditionalEdges("executeRegisteredAgent", ne).addEdge("exit", j);
+class v {
   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);
+    const { agent: n } = e;
+    if (this.agentRegistry.has(n.id))
+      throw new Error(`Duplicate agent id: ${n.id}`);
+    this.agentRegistry.set(n.id, e);
   }
   get(e) {
     return this.agentRegistry.get(e);
@@ -194,31 +203,31 @@ class ee {
     return [...this.agentRegistry.values()];
   }
 }
-class te {
+class ae {
   /**
    * Create a new InterruptHandler tied to a specific compiled graph and config.
    */
-  constructor(e, r) {
-    this.graph = e, this.config = { ...r };
+  constructor(e, n) {
+    this.graph = e, this.config = { ...n };
   }
   /**
    * Returns a promise that resolves when the user provides a HITL response.
    */
   async waitForUser() {
-    return await new Promise((e, r) => {
-      this.resolveWait = e, this.rejectWait = r;
+    return await new Promise((e, n) => {
+      this.resolveWait = e, this.rejectWait = n;
     });
   }
   /**
    * Resume graph execution after the UI responds to an interrupt.
    */
-  handle(e, r) {
+  handle(e, n) {
     try {
       const s = {
         agentId: e.agentId,
         id: e.id,
-        payload: r
-      }, n = this.graph.streamEvents(null, {
+        payload: n
+      }, r = this.graph.streamEvents(null, {
         ...this.config,
         configurable: {
           ...this.config.configurable,
@@ -227,7 +236,7 @@ class te {
         subgraphs: !0,
         version: "v2"
       });
-      this.resolveWait?.(n);
+      this.resolveWait?.(r);
     } catch (s) {
       this.rejectWait?.(s);
     } finally {
@@ -241,157 +250,157 @@ class te {
     this.rejectWait && (this.rejectWait(new Error("Request cancelled by user.")), this.resolveWait = void 0, this.rejectWait = void 0);
   }
 }
-const re = async (t) => {
+const ie = async (t) => {
   try {
-    return await (await M()).embedDocuments(t);
+    return await (await F()).embedDocuments(t);
   } catch (e) {
     throw console.error("Failed to generate embeddings:", e), e;
   }
-}, x = async (t, e) => {
-  const r = e.get(t);
-  if (r)
-    return r;
-  const s = await re([t]);
+}, S = async (t, e) => {
+  const n = e.get(t);
+  if (n)
+    return n;
+  const s = await ie([t]);
   return e.set(t, s[0]), s[0];
 };
-async function ne(t, e, r, s) {
-  const n = `req-${Date.now()}`, i = {
+async function oe(t, e, n, s) {
+  const r = `req-${Date.now()}`, i = {
     type: "layerSearch",
-    precomputedEmbedding: s ? await x(t, s) : void 0,
-    requestId: n,
-    minScore: r
+    precomputedEmbedding: s ? await S(t, s) : void 0,
+    requestId: r,
+    minScore: n
   };
   return await new Promise((c) => {
-    const d = (a) => {
-      a.data.requestId === n && c(a.data.results);
+    const d = (o) => {
+      o.data.requestId === r && c(o.data.results);
     };
     e.addEventListener("message", d, { once: !0 }), e.postMessage(i);
   });
 }
-function se(t) {
+function ce(t) {
   const { worker: e } = t;
   return {
     async searchLayers({
-      text: r,
+      text: n,
       minScore: s,
-      embeddingCache: n
+      embeddingCache: r
     }) {
-      return await ne(r, e, s, n);
+      return await oe(n, e, s, r);
     }
   };
 }
-const ae = async ({
+const de = async ({
   combinedQuery: t,
   layerIds: e,
-  embeddingsWorker: r,
+  embeddingsWorker: n,
   minScore: s,
-  topResults: n,
-  embeddingCache: o
+  topResults: r,
+  embeddingCache: a
 }) => {
-  const i = `req-${Date.now()}`, c = o ? await x(t, o) : void 0, d = {
+  const i = `req-${Date.now()}`, c = a ? await S(t, a) : void 0, d = {
     type: "fieldSearch",
     layerIdForFieldsSearch: e,
     precomputedEmbedding: c,
     requestId: i,
     minScore: s,
-    topResults: n
+    topResults: r
   };
-  return await new Promise((a) => {
+  return await new Promise((o) => {
     const g = (u) => {
       if (u.data.requestId !== i)
         return;
-      const p = u.data.results.map(({ layerId: y, results: m }) => ({
+      const p = u.data.results.map(({ layerId: y, results: h }) => ({
         layerId: y,
-        results: m
+        results: h
       }));
-      a(p);
+      o(p);
     };
-    r.addEventListener("message", g, { once: !0 }), r.postMessage(d);
+    n.addEventListener("message", g, { once: !0 }), n.postMessage(d);
   });
 };
-function ie(t) {
+function ge(t) {
   const { worker: e } = t;
   return {
-    async searchFields({ text: r, layerIds: s, minScore: n, topResults: o, embeddingCache: i }) {
-      return await ae({
-        combinedQuery: r,
+    async searchFields({ text: n, layerIds: s, minScore: r, topResults: a, embeddingCache: i }) {
+      return await de({
+        combinedQuery: n,
         layerIds: s,
         embeddingsWorker: e,
-        minScore: n,
-        topResults: o,
+        minScore: r,
+        topResults: a,
         embeddingCache: i
       });
     }
   };
 }
-const oe = (t) => {
-  const e = F.safeParse(t);
+const ue = (t) => {
+  const e = $.safeParse(t);
   if (!e.success)
     throw new Error("Embeddings response validation failed. Regenerate embeddings.");
   return e.data;
-}, ce = (t, e) => {
-  const r = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Map();
-  if (e.allLayers.forEach((n) => {
-    n instanceof T && s.set(n.id, n);
+}, le = (t, e) => {
+  const n = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Map();
+  if (e.allLayers.forEach((r) => {
+    r instanceof N && s.set(r.id, r);
   }), t.length !== s.size)
     throw new Error("Layer count mismatch during registry restoration. Regenerate embeddings.");
-  for (const n of t) {
-    const o = s.get(n.id);
-    if (!o)
+  for (const r of t) {
+    const a = s.get(r.id);
+    if (!a)
       throw new Error(
-        `Layer with ID ${n.id} not found in the original map during registry restoration. Regenerate embeddings.`
+        `Layer with ID ${r.id} not found in the original map during registry restoration. Regenerate embeddings.`
       );
-    if (n.fields.length !== o.fields.length)
+    if (r.fields.length !== a.fields.length)
       throw new Error(
-        `Field count mismatch for layer ID ${n.id} during registry restoration. Regenerate embeddings.`
+        `Field count mismatch for layer ID ${r.id} during registry restoration. Regenerate embeddings.`
       );
     const i = {
-      name: n.name,
-      title: n.title,
-      description: n.description
+      name: r.name,
+      title: r.title,
+      description: r.description
     }, c = /* @__PURE__ */ new Map();
-    for (const d of n.fields) {
-      const a = o.fieldsIndex.get(d.name);
-      if (!a)
+    for (const d of r.fields) {
+      const o = a.fieldsIndex.get(d.name);
+      if (!o)
         throw new Error(
-          `Field with name ${d.name} not found in the original layer ${n.id} during registry restoration. Regenerate embeddings.`
+          `Field with name ${d.name} not found in the original layer ${r.id} during registry restoration. Regenerate embeddings.`
         );
       c.set(d.name, {
         name: d.name,
-        alias: o.getFieldAlias(d.name) ?? d.alias,
+        alias: a.getFieldAlias(d.name) ?? d.alias,
         description: d.description,
-        type: a.type || "unknown",
-        valueType: a.valueType || "unknown",
-        domain: o.getFieldDomain(d.name) ?? void 0
+        type: o.type || "unknown",
+        valueType: o.valueType || "unknown",
+        domain: a.getFieldDomain(d.name) ?? void 0
       });
     }
-    r.set(n.id, {
+    n.set(r.id, {
       layerItem: i,
       fieldRegistry: c
     });
   }
-  return r;
-}, de = async (t) => {
+  return n;
+}, he = async (t) => {
   try {
-    return (await U(t, {
+    return (await G(t, {
       responseType: "json"
     })).data;
   } catch (e) {
     throw new Error(`Failed to fetch data from ${t}: ${String(e)}`);
   }
-}, ue = async (t) => {
+}, me = 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((i) => i.resource.path === "embeddings-v01.json");
+  const { resources: n } = await e.portalItem.fetchResources(), s = n.find((i) => i.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 de(s.resource.url);
-  return oe(n);
+  const r = await he(s.resource.url);
+  return ue(r);
 };
-class b {
+class R {
   constructor() {
-    this.orchestratorReady = !1, this.chatHistory = [], this.priorSteps = [], this.sharedState = {}, this.agentRegistry = new ee(), this.activeRunId = "", this.cancelledRunIds = /* @__PURE__ */ new Set(), this.streamEpoch = 0;
+    this.orchestratorReady = !1, this.chatHistory = [], this.priorSteps = [], this.sharedState = {}, this.agentRegistry = new v(), this.activeRunId = "", this.cancelledRunIds = /* @__PURE__ */ new Set(), this.streamEpoch = 0;
   }
   /**
    * Creates and returns an AI-ready Orchestrator instance.
@@ -399,19 +408,19 @@ class b {
    * @returns Ready Orchestrator.
    */
   static async init(e) {
-    const r = new b();
+    const n = new R();
     try {
       if (e.view?.map) {
-        await O.whenOnce(() => e.view.ready);
-        const s = await ue(e.view), n = ce(
+        await U.whenOnce(() => e.view.ready);
+        const s = await me(e.view), r = le(
           s.layers,
           e.view.map
         );
-        r.layersAndFieldsRegistry = n, r.embeddingsWorker = await G(s);
+        n.layersAndFieldsRegistry = r, n.embeddingsWorker = await _(s);
       }
       return e.agents?.forEach((s) => {
-        r.agentRegistry.register(s);
-      }), r.orchestratorReady = !0, r;
+        n.agentRegistry.register(s);
+      }), n.orchestratorReady = !0, n;
     } catch (s) {
       throw console.error("Orchestrator initialization failed:", s), s;
     }
@@ -423,35 +432,41 @@ class b {
    *  - `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 for this run.
    */
-  async *ask(e) {
+  async *ask(e, n = {}) {
     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(n);
+    if (!s.list().length)
+      throw new Error("Orchestrator has no agents selected for this request.");
     if (++this.streamEpoch, !e.trim())
       return;
-    const r = q();
-    this.activeRunId = r, this.activeAbortController = new AbortController(), this.graph || (this.graph = Z().compile({ checkpointer: new j() }));
-    const s = this.embeddingsWorker ? se({ worker: this.embeddingsWorker }) : void 0, n = this.embeddingsWorker ? ie({ worker: this.embeddingsWorker }) : void 0, o = /* @__PURE__ */ new Map(), i = {
+    const r = P();
+    this.activeRunId = r, this.activeAbortController = new AbortController(), this.graph || (this.graph = se().compile({ checkpointer: new H() }));
+    const a = this.embeddingsWorker ? ce({ worker: this.embeddingsWorker }) : void 0, i = this.embeddingsWorker ? ge({ worker: this.embeddingsWorker }) : void 0, c = /* @__PURE__ */ new Map(), d = n.routing === "direct" ? { mode: "direct", agentId: n.agentId } : { mode: "auto" }, o = {
       // eslint-disable-next-line @typescript-eslint/naming-convention
       thread_id: r,
       hitlResponse: null,
       services: {
-        layerSearch: s,
-        fieldSearch: n,
+        layerSearch: a,
+        fieldSearch: i,
         layersAndFieldsRegistry: this.layersAndFieldsRegistry,
-        agentRegistry: this.agentRegistry,
-        embeddingCache: o
+        agentRegistry: s,
+        embeddingCache: c
       }
-    }, c = {
+    }, g = {
       version: "v2",
       streamMode: "custom",
       signal: this.activeAbortController.signal,
-      configurable: i,
+      configurable: o,
       subgraphs: !0
-    }, d = this.graph?.streamEvents(
+    }, u = this.graph?.streamEvents(
       {
+        routing: d,
         agentExecutionContext: {
           userRequest: e,
           messages: this.chatHistory,
@@ -459,9 +474,9 @@ class b {
           sharedState: this.sharedState
         }
       },
-      c
-    ), a = ++this.streamEpoch;
-    if (yield* this.pipeStream(d, a, r), this.isRunCancelled(r)) {
+      g
+    ), p = ++this.streamEpoch;
+    if (yield* this.pipeStream(u, p, r), this.isRunCancelled(r)) {
       yield { runId: r, timestamp: Date.now(), type: "cancelled", reason: "user" };
       return;
     }
@@ -470,24 +485,24 @@ class b {
         yield { runId: r, timestamp: Date.now(), type: "cancelled", reason: "user" };
         return;
       }
-      const m = (await this.graph.getState(c, { subgraphs: !0 })).tasks.find((h) => h.interrupts.length > 0)?.interrupts[0]?.value;
-      if (!m)
+      const w = (await this.graph.getState(g, { subgraphs: !0 })).tasks.find((m) => m.interrupts.length > 0)?.interrupts[0]?.value;
+      if (!w)
         break;
-      this.currentInterrupt = m, this.interruptHandler = new te(this.graph, c), yield { runId: r, timestamp: Date.now(), type: "interrupt", interrupt: m };
+      this.currentInterrupt = w, this.interruptHandler = new ae(this.graph, g), yield { runId: r, timestamp: Date.now(), type: "interrupt", interrupt: w };
       try {
-        const h = await this.interruptHandler.waitForUser(), S = ++this.streamEpoch;
-        yield* this.pipeStream(h, S, r);
-      } catch (h) {
+        const m = await this.interruptHandler.waitForUser(), I = ++this.streamEpoch;
+        yield* this.pipeStream(m, I, r);
+      } catch (m) {
         if (this.isRunCancelled(r)) {
           yield { runId: r, timestamp: Date.now(), type: "cancelled", reason: "user" };
           return;
         }
-        if (h) {
+        if (m) {
           yield {
             runId: r,
             timestamp: Date.now(),
             type: "error",
-            error: { message: h?.message }
+            error: { message: m?.message }
           };
           return;
         }
@@ -497,16 +512,16 @@ class b {
       yield { runId: r, timestamp: Date.now(), type: "cancelled", reason: "user" };
       return;
     }
-    const u = (await this.graph.getState(c, { subgraphs: !0 })).values;
+    const h = (await this.graph.getState(g, { subgraphs: !0 })).values;
     if (this.isRunCancelled(r)) {
       yield { runId: r, timestamp: Date.now(), type: "cancelled", reason: "user" };
       return;
     }
-    this.chatHistory = u.agentExecutionContext.messages.length ? u.agentExecutionContext.messages : this.chatHistory, this.priorSteps = u.agentExecutionContext.priorSteps?.slice(-5) ?? [], this.sharedState = u.agentExecutionContext.sharedState ?? {}, yield {
+    this.chatHistory = h.agentExecutionContext.messages.length ? h.agentExecutionContext.messages : this.chatHistory, this.priorSteps = h.agentExecutionContext.priorSteps?.slice(-5) ?? [], this.sharedState = h.agentExecutionContext.sharedState ?? {}, yield {
       runId: r,
       timestamp: Date.now(),
       type: "completed",
-      result: { content: u.finalOutputMessage }
+      result: { content: h.finalOutputMessage }
     };
   }
   /**
@@ -540,21 +555,34 @@ class b {
   cancel() {
     this.activeRunId && (this.cancelledRunIds.add(this.activeRunId), this.activeAbortController?.abort(), ++this.streamEpoch, this.interruptHandler?.cancel());
   }
-  async *pipeStream(e, r, s) {
-    for await (const n of e) {
-      if (this.isRunCancelled(s) || r !== this.streamEpoch)
+  async *pipeStream(e, n, s) {
+    for await (const r of e) {
+      if (this.isRunCancelled(s) || n !== this.streamEpoch)
         break;
-      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 {
+      r.event === "on_custom_event" && r.name === "trace_message" ? yield { runId: s, timestamp: Date.now(), type: "trace", data: r.data } : r.name === "graph_ux_suggestion" && (yield {
         runId: s,
         timestamp: Date.now(),
         type: "ux-suggestion",
-        suggestion: n.data
+        suggestion: r.data
       });
     }
   }
   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 n = e.routing === "direct" ? [e.agentId] : e.agentIds, s = n ? n.map((a) => {
+      const i = this.agentRegistry.get(a);
+      if (!i)
+        throw new Error(`Agent is not registered: ${a}`);
+      return i;
+    }) : this.agentRegistry.list(), r = new v();
+    return s.forEach((a) => r.register(a)), r;
+  }
   /**
    * Disposes this instance by terminating the embeddings worker
    * and cleaning up all related resources.
@@ -564,6 +592,6 @@ class b {
   }
 }
 export {
-  b as O,
-  re as g
+  R as O,
+  ie as g
 };